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

package/dist/es/core/axis.js

@@ -13,11 +13,9 @@ import createAxisGridLine from './utils/create-axis-grid-line';
 import { NONE, BLACK, CENTER, TOP, BOTTOM, LEFT, RIGHT, OUTSIDE, X, Y, WIDTH, HEIGHT } from '../common/constants';
 import { alignPathToPixel, deepExtend, getTemplate, grep, defined, isObject, inArray, limitValue, round, setDefaultOptions } from '../common';
 
-var Axis = (function (ChartElement) {
-    function Axis(options, chartService) {
-        if ( chartService === void 0 ) chartService = new ChartService();
-
-        ChartElement.call(this, options);
+class Axis extends ChartElement {
+    constructor(options, chartService = new ChartService()) {
+        super(options);
 
         this.chartService = chartService;
 
@@ -63,42 +61,36 @@ var Axis = (function (ChartElement) {
         this.createNotes();
     }
 
-    if ( ChartElement ) Axis.__proto__ = ChartElement;
-    Axis.prototype = Object.create( ChartElement && ChartElement.prototype );
-    Axis.prototype.constructor = Axis;
-
-    Axis.prototype.initFields = function initFields () {
-    };
+    initFields() {
+    }
 
     // abstract labelsCount(): Number
     // abstract createAxisLabel(index, options): AxisLabel
 
-    Axis.prototype.labelsRange = function labelsRange () {
+    labelsRange() {
         return {
             min: this.options.labels.skip,
             max: this.labelsCount()
         };
-    };
+    }
 
-    Axis.prototype.normalizeLabelRotation = function normalizeLabelRotation (labelOptions) {
-        var rotation = labelOptions.rotation;
+    normalizeLabelRotation(labelOptions) {
+        const rotation = labelOptions.rotation;
 
         if (isObject(rotation)) {
             labelOptions.alignRotation = rotation.align;
             labelOptions.rotation = rotation.angle;
         }
-    };
-
-    Axis.prototype.createLabels = function createLabels () {
-        var this$1 = this;
+    }
 
-        var options = this.options;
-        var align = options.vertical ? RIGHT : CENTER;
-        var labelOptions = deepExtend({ }, options.labels, {
+    createLabels() {
+        const options = this.options;
+        const align = options.vertical ? RIGHT : CENTER;
+        const labelOptions = deepExtend({ }, options.labels, {
             align: align,
             zIndex: options.zIndex
         });
-        var step = Math.max(1, labelOptions.step);
+        const step = Math.max(1, labelOptions.step);
 
         this.clearLabels();
 
@@ -109,55 +101,51 @@ var Axis = (function (ChartElement) {
                 options.autoRotateLabels = true;
             }
 
-            var range = this.labelsRange();
-            for (var idx = range.min; idx < range.max; idx += step) {
-                var labelContext = { index: idx, count: range.max };
-                var label = this$1.createAxisLabel(idx, labelOptions, labelContext);
+            const range = this.labelsRange();
+            for (let idx = range.min; idx < range.max; idx += step) {
+                const labelContext = { index: idx, count: range.max };
+                let label = this.createAxisLabel(idx, labelOptions, labelContext);
                 if (label) {
-                    this$1.append(label);
-                    this$1.labels.push(label);
+                    this.append(label);
+                    this.labels.push(label);
                 }
             }
         }
-    };
+    }
 
-    Axis.prototype.clearLabels = function clearLabels () {
-        this.children = grep(this.children, function (child) { return !(child instanceof AxisLabel); });
+    clearLabels() {
+        this.children = grep(this.children, child => !(child instanceof AxisLabel));
         this.labels = [];
-    };
-
-    Axis.prototype.clearTitle = function clearTitle () {
-        var this$1 = this;
+    }
 
+    clearTitle() {
         if (this.title) {
-            this.children = grep(this.children, function (child) { return child !== this$1.title; });
+            this.children = grep(this.children, child => child !== this.title);
             this.title = undefined;
         }
-    };
+    }
 
-    Axis.prototype.clear = function clear () {
+    clear() {
         this.clearLabels();
         this.clearTitle();
-    };
-
-    Axis.prototype.lineBox = function lineBox () {
-        var ref = this;
-        var options = ref.options;
-        var box = ref.box;
-        var vertical = options.vertical;
-        var mirror = options.labels.mirror;
-        var axisX = mirror ? box.x1 : box.x2;
-        var axisY = mirror ? box.y2 : box.y1;
-        var lineWidth = options.line.width || 0;
+    }
+
+    lineBox() {
+        const { options, box } = this;
+        const vertical = options.vertical;
+        const mirror = options.labels.mirror;
+        const axisX = mirror ? box.x1 : box.x2;
+        const axisY = mirror ? box.y2 : box.y1;
+        const lineWidth = options.line.width || 0;
 
         return vertical ?
             new Box(axisX, box.y1, axisX, box.y2 - lineWidth) :
             new Box(box.x1, axisY, box.x2 - lineWidth, axisY);
-    };
+    }
 
-    Axis.prototype.createTitle = function createTitle () {
-        var options = this.options;
-        var titleOptions = deepExtend({
+    createTitle() {
+        const options = this.options;
+        const titleOptions = deepExtend({
             rotation: options.vertical ? -90 : 0,
             text: "",
             zIndex: 1,
@@ -165,30 +153,28 @@ var Axis = (function (ChartElement) {
         }, options.title);
 
         if (titleOptions.visible && titleOptions.text) {
-            var title = new TextBox(titleOptions.text, titleOptions);
+            const title = new TextBox(titleOptions.text, titleOptions);
             this.append(title);
             this.title = title;
         }
-    };
-
-    Axis.prototype.createNotes = function createNotes () {
-        var this$1 = this;
+    }
 
-        var options = this.options;
-        var notes = options.notes;
-        var items = notes.data || [];
+    createNotes() {
+        const options = this.options;
+        const notes = options.notes;
+        const items = notes.data || [];
 
         this.notes = [];
 
-        for (var i = 0; i < items.length; i++) {
-            var item = deepExtend({}, notes, items[i]);
-            item.value = this$1.parseNoteValue(item.value);
+        for (let i = 0; i < items.length; i++) {
+            const item = deepExtend({}, notes, items[i]);
+            item.value = this.parseNoteValue(item.value);
 
-            var note = new Note({
+            const note = new Note({
                 value: item.value,
                 text: item.label.text,
                 dataItem: item
-            }, item, this$1.chartService);
+            }, item, this.chartService);
 
             if (note.options.visible) {
                 if (defined(note.options.position)) {
@@ -204,31 +190,31 @@ var Axis = (function (ChartElement) {
                         note.options.position = options.reverse ? BOTTOM : TOP;
                     }
                 }
-                this$1.append(note);
-                this$1.notes.push(note);
+                this.append(note);
+                this.notes.push(note);
             }
         }
-    };
+    }
 
-    Axis.prototype.parseNoteValue = function parseNoteValue (value) {
+    parseNoteValue(value) {
         return value;
-    };
+    }
 
-    Axis.prototype.renderVisual = function renderVisual () {
-        ChartElement.prototype.renderVisual.call(this);
+    renderVisual() {
+        super.renderVisual();
 
         this.createPlotBands();
-    };
+    }
 
-    Axis.prototype.createVisual = function createVisual () {
-        ChartElement.prototype.createVisual.call(this);
+    createVisual() {
+        super.createVisual();
 
         this.createBackground();
         this.createLine();
-    };
+    }
 
-    Axis.prototype.gridLinesVisual = function gridLinesVisual () {
-        var gridLines = this._gridLines;
+    gridLinesVisual() {
+        let gridLines = this._gridLines;
         if (!gridLines) {
             gridLines = this._gridLines = new draw.Group({
                 zIndex: -2
@@ -237,25 +223,25 @@ var Axis = (function (ChartElement) {
         }
 
         return gridLines;
-    };
-
-    Axis.prototype.createTicks = function createTicks (lineGroup) {
-        var options = this.options;
-        var lineBox = this.lineBox();
-        var mirror = options.labels.mirror;
-        var majorUnit = options.majorTicks.visible ? options.majorUnit : 0;
-        var tickLineOptions = {
+    }
+
+    createTicks(lineGroup) {
+        const options = this.options;
+        const lineBox = this.lineBox();
+        const mirror = options.labels.mirror;
+        const majorUnit = options.majorTicks.visible ? options.majorUnit : 0;
+        const tickLineOptions = {
             // TODO
             // _alignLines: options._alignLines,
             vertical: options.vertical
         };
 
         function render(tickPositions, tickOptions, skipUnit) {
-            var count = tickPositions.length;
-            var step = Math.max(1, tickOptions.step);
+            const count = tickPositions.length;
+            const step = Math.max(1, tickOptions.step);
 
             if (tickOptions.visible) {
-                for (var i = tickOptions.skip; i < count; i += step) {
+                for (let i = tickOptions.skip; i < count; i += step) {
                     if (defined(skipUnit) && (i % skipUnit === 0)) {
                         continue;
                     }
@@ -271,15 +257,15 @@ var Axis = (function (ChartElement) {
 
         render(this.getMajorTickPositions(), options.majorTicks);
         render(this.getMinorTickPositions(), options.minorTicks, majorUnit / options.minorUnit);
-    };
+    }
 
-    Axis.prototype.createLine = function createLine () {
-        var options = this.options;
-        var line = options.line;
-        var lineBox = this.lineBox();
+    createLine() {
+        const options = this.options;
+        const line = options.line;
+        const lineBox = this.lineBox();
 
         if (line.width > 0 && line.visible) {
-            var path = new draw.Path({
+            const path = new draw.Path({
                 stroke: {
                     width: line.width,
                     color: line.color,
@@ -298,17 +284,17 @@ var Axis = (function (ChartElement) {
                 alignPathToPixel(path);
             }
 
-            var group = this._lineGroup = new draw.Group();
+            const group = this._lineGroup = new draw.Group();
             group.append(path);
 
             this.visual.append(group);
             this.createTicks(group);
         }
-    };
+    }
 
-    Axis.prototype.getActualTickSize = function getActualTickSize () {
-        var options = this.options;
-        var tickSize = 0;
+    getActualTickSize() {
+        const options = this.options;
+        let tickSize = 0;
 
         if (options.majorTicks.visible && options.minorTicks.visible) {
             tickSize = Math.max(options.majorTicks.size, options.minorTicks.size);
@@ -319,13 +305,11 @@ var Axis = (function (ChartElement) {
         }
 
         return tickSize;
-    };
+    }
 
-    Axis.prototype.createBackground = function createBackground () {
-        var ref = this;
-        var options = ref.options;
-        var box = ref.box;
-        var background = options.background;
+    createBackground() {
+        const { options, box } = this;
+        const background = options.background;
 
         if (background) {
             this._backgroundPath = draw.Path.fromRect(box.toRect(), {
@@ -337,43 +321,41 @@ var Axis = (function (ChartElement) {
 
             this.visual.append(this._backgroundPath);
         }
-    };
-
-    Axis.prototype.createPlotBands = function createPlotBands () {
-        var this$1 = this;
+    }
 
-        var options = this.options;
-        var plotBands = options.plotBands || [];
-        var vertical = options.vertical;
-        var plotArea = this.plotArea;
+    createPlotBands() {
+        const options = this.options;
+        const plotBands = options.plotBands || [];
+        const vertical = options.vertical;
+        const plotArea = this.plotArea;
 
         if (plotBands.length === 0) {
             return;
         }
 
-        var group = this._plotbandGroup = new draw.Group({
+        const group = this._plotbandGroup = new draw.Group({
             zIndex: -1
         });
 
-        var altAxis = grep(this.pane.axes, function (axis) { return axis.options.vertical !== this$1.options.vertical; })[0];
+        const altAxis = grep(this.pane.axes, axis => axis.options.vertical !== this.options.vertical)[0];
 
-        for (var idx = 0; idx < plotBands.length; idx++) {
-            var item = plotBands[idx];
-            var slotX = (void 0), slotY = (void 0);
-            var labelOptions = item.label;
-            var label = (void 0);
+        for (let idx = 0; idx < plotBands.length; idx++) {
+            let item = plotBands[idx];
+            let slotX, slotY;
+            let labelOptions = item.label;
+            let label;
 
             if (vertical) {
                 slotX = (altAxis || plotArea.axisX).lineBox();
-                slotY = this$1.getSlot(item.from, item.to, true);
+                slotY = this.getSlot(item.from, item.to, true);
             } else {
-                slotX = this$1.getSlot(item.from, item.to, true);
+                slotX = this.getSlot(item.from, item.to, true);
                 slotY = (altAxis || plotArea.axisY).lineBox();
             }
 
             if (labelOptions) {
                 labelOptions.vAlign = labelOptions.position || LEFT;
-                label = this$1.createPlotBandLabel(
+                label = this.createPlotBandLabel(
                     labelOptions,
                     item,
                     new Box(
@@ -387,12 +369,12 @@ var Axis = (function (ChartElement) {
             }
 
             if (slotX.width() !== 0 && slotY.height() !== 0) {
-                var bandRect = new geom.Rect(
+                const bandRect = new geom.Rect(
                     [ slotX.x1, slotY.y1 ],
                     [ slotX.width(), slotY.height() ]
                 );
 
-                var path = draw.Path.fromRect(bandRect, {
+                const path = draw.Path.fromRect(bandRect, {
                     fill: {
                         color: item.color,
                         opacity: item.opacity
@@ -408,19 +390,19 @@ var Axis = (function (ChartElement) {
         }
 
         this.appendVisual(group);
-    };
+    }
 
-    Axis.prototype.createPlotBandLabel = function createPlotBandLabel (label, item, box) {
+    createPlotBandLabel(label, item, box) {
 
         if (label.visible === false) {
             return null;
         }
 
-        var text = label.text;
-        var textbox;
+        let text = label.text;
+        let textbox;
 
         if (defined(label) && label.visible) {
-            var labelTemplate = getTemplate(label);
+            const labelTemplate = getTemplate(label);
             if (labelTemplate) {
                 text = labelTemplate({ text: text, item: item });
             } else if (label.format) {
@@ -437,34 +419,31 @@ var Axis = (function (ChartElement) {
         textbox.renderVisual();
 
         return textbox.visual;
-    };
-
-    Axis.prototype.createGridLines = function createGridLines (altAxis) {
-        var options = this.options;
-        var minorGridLines = options.minorGridLines;
-        var majorGridLines = options.majorGridLines;
-        var minorUnit = options.minorUnit;
-        var vertical = options.vertical;
-        var axisLineVisible = altAxis.options.line.visible;
-        var majorUnit = majorGridLines.visible ? options.majorUnit : 0;
-        var lineBox = altAxis.lineBox();
-        var linePos = lineBox[vertical ? "y1" : "x1"];
-        var lineOptions = {
+    }
+
+    createGridLines(altAxis) {
+        const options = this.options;
+        const { minorGridLines, majorGridLines, minorUnit, vertical } = options;
+        const axisLineVisible = altAxis.options.line.visible;
+        const majorUnit = majorGridLines.visible ? options.majorUnit : 0;
+        const lineBox = altAxis.lineBox();
+        const linePos = lineBox[vertical ? "y1" : "x1"];
+        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(tickPositions, gridLine, skipUnit) {
-            var count = tickPositions.length;
-            var step = Math.max(1, gridLine.step);
+            const count = tickPositions.length;
+            const step = Math.max(1, gridLine.step);
 
             if (gridLine.visible) {
-                for (var i = gridLine.skip; i < count; i += step) {
-                    var pos = round(tickPositions[i]);
+                for (let i = gridLine.skip; i < count; i += step) {
+                    let pos = round(tickPositions[i]);
                     if (!inArray(pos, majorTicks)) {
                         if (i % skipUnit !== 0 && (!axisLineVisible || linePos !== pos)) {
                             lineOptions.position = pos;
@@ -481,24 +460,21 @@ var Axis = (function (ChartElement) {
         render(this.getMinorTickPositions(), minorGridLines, majorUnit / minorUnit);
 
         return container.children;
-    };
-
-    Axis.prototype.reflow = function reflow (box) {
-        var ref = this;
-        var options = ref.options;
-        var labels = ref.labels;
-        var title = ref.title;
-        var vertical = options.vertical;
-        var count = labels.length;
-        var sizeFn = vertical ? WIDTH : HEIGHT;
-        var titleSize = title ? title.box[sizeFn]() : 0;
-        var space = this.getActualTickSize() + options.margin + titleSize;
-        var rootBox = (this.getRoot() || {}).box || box;
-        var boxSize = rootBox[sizeFn]();
-        var maxLabelSize = 0;
-
-        for (var i = 0; i < count; i++) {
-            var labelSize = labels[i].box[sizeFn]();
+    }
+
+    reflow(box) {
+        const { options, labels, title } = this;
+        const vertical = options.vertical;
+        const count = labels.length;
+        const sizeFn = vertical ? WIDTH : HEIGHT;
+        const titleSize = title ? title.box[sizeFn]() : 0;
+        const space = this.getActualTickSize() + options.margin + titleSize;
+        const rootBox = (this.getRoot() || {}).box || box;
+        const boxSize = rootBox[sizeFn]();
+        let maxLabelSize = 0;
+
+        for (let i = 0; i < count; i++) {
+            let labelSize = labels[i].box[sizeFn]();
             if (labelSize + space <= boxSize) {
                 maxLabelSize = Math.max(maxLabelSize, labelSize);
             }
@@ -519,38 +495,34 @@ var Axis = (function (ChartElement) {
         this.arrangeTitle();
         this.arrangeLabels();
         this.arrangeNotes();
-    };
+    }
 
-    Axis.prototype.getLabelsTickPositions = function getLabelsTickPositions () {
+    getLabelsTickPositions() {
         return this.getMajorTickPositions();
-    };
+    }
 
-    Axis.prototype.labelTickIndex = function labelTickIndex (label) {
+    labelTickIndex(label) {
         return label.index;
-    };
-
-    Axis.prototype.arrangeLabels = function arrangeLabels () {
-        var this$1 = this;
-
-        var ref = this;
-        var options = ref.options;
-        var labels = ref.labels;
-        var labelsBetweenTicks = this.labelsBetweenTicks();
-        var vertical = options.vertical;
-        var mirror = options.labels.mirror;
-        var tickPositions = this.getLabelsTickPositions();
-
-        for (var idx = 0; idx < labels.length; idx++) {
-            var label = labels[idx];
-            var tickIx = this$1.labelTickIndex(label);
-            var labelSize = vertical ? label.box.height() : label.box.width();
-            var firstTickPosition = tickPositions[tickIx];
-            var nextTickPosition = tickPositions[tickIx + 1];
-            var positionStart = (void 0), positionEnd = (void 0);
+    }
+
+    arrangeLabels() {
+        const { options, labels } = this;
+        const labelsBetweenTicks = this.labelsBetweenTicks();
+        const vertical = options.vertical;
+        const mirror = options.labels.mirror;
+        const tickPositions = this.getLabelsTickPositions();
+
+        for (let idx = 0; idx < labels.length; idx++) {
+            const label = labels[idx];
+            const tickIx = this.labelTickIndex(label);
+            const labelSize = vertical ? label.box.height() : label.box.width();
+            const firstTickPosition = tickPositions[tickIx];
+            const nextTickPosition = tickPositions[tickIx + 1];
+            let positionStart, positionEnd;
 
             if (vertical) {
                 if (labelsBetweenTicks) {
-                    var middle = firstTickPosition + (nextTickPosition - firstTickPosition) / 2;
+                    const middle = firstTickPosition + (nextTickPosition - firstTickPosition) / 2;
                     positionStart = middle - (labelSize / 2);
                 } else {
                     positionStart = firstTickPosition - (labelSize / 2);
@@ -567,21 +539,19 @@ var Axis = (function (ChartElement) {
                 }
             }
 
-            this$1.positionLabel(label, mirror, positionStart, positionEnd);
+            this.positionLabel(label, mirror, positionStart, positionEnd);
         }
-    };
-
-    Axis.prototype.positionLabel = function positionLabel (label, mirror, positionStart, positionEnd) {
-        if ( positionEnd === void 0 ) positionEnd = positionStart;
+    }
 
-        var options = this.options;
-        var vertical = options.vertical;
-        var lineBox = this.lineBox();
-        var labelOffset = this.getActualTickSize() + options.margin;
-        var labelBox;
+    positionLabel(label, mirror, positionStart, positionEnd = positionStart) {
+        const options = this.options;
+        const vertical = options.vertical;
+        const lineBox = this.lineBox();
+        const labelOffset = this.getActualTickSize() + options.margin;
+        let labelBox;
 
         if (vertical) {
-            var labelX = lineBox.x2;
+            let labelX = lineBox.x2;
 
             if (mirror) {
                 labelX += labelOffset;
@@ -593,7 +563,7 @@ var Axis = (function (ChartElement) {
 
             labelBox = label.box.move(labelX, positionStart);
         } else {
-            var labelY = lineBox.y1;
+            let labelY = lineBox.y1;
 
             if (mirror) {
                 labelY -= labelOffset + label.box.height();
@@ -610,9 +580,9 @@ var Axis = (function (ChartElement) {
         }
 
         label.reflow(labelBox);
-    };
+    }
 
-    Axis.prototype.autoRotateLabelAngle = function autoRotateLabelAngle (labelBox, slotWidth) {
+    autoRotateLabelAngle(labelBox, slotWidth) {
         if (labelBox.width() < slotWidth) {
             return 0;
         }
@@ -622,24 +592,22 @@ var Axis = (function (ChartElement) {
         }
 
         return -45;
-    };
-
-    Axis.prototype.autoRotateLabels = function autoRotateLabels () {
-        var this$1 = this;
+    }
 
+    autoRotateLabels() {
         if (!this.options.autoRotateLabels || this.options.vertical) {
             return false;
         }
 
-        var tickPositions = this.getMajorTickPositions();
-        var labels = this.labels;
-        var limit = Math.min(labels.length, tickPositions.length - 1);
-        var angle = 0;
+        const tickPositions = this.getMajorTickPositions();
+        const labels = this.labels;
+        const limit = Math.min(labels.length, tickPositions.length - 1);
+        let angle = 0;
 
-        for (var idx = 0; idx < limit; idx++) {
-            var width = Math.abs(tickPositions[idx + 1] - tickPositions[idx]);
-            var labelBox = labels[idx].box;
-            var labelAngle = this$1.autoRotateLabelAngle(labelBox, width);
+        for (let idx = 0; idx < limit; idx++) {
+            const width = Math.abs(tickPositions[idx + 1] - tickPositions[idx]);
+            const labelBox = labels[idx].box;
+            const labelAngle = this.autoRotateLabelAngle(labelBox, width);
 
             if (labelAngle !== 0) {
                 angle = labelAngle;
@@ -651,21 +619,19 @@ var Axis = (function (ChartElement) {
         }
 
         if (angle !== 0) {
-            for (var idx$1 = 0; idx$1 < labels.length; idx$1++) {
-                labels[idx$1].options.rotation = angle;
-                labels[idx$1].reflow(new Box());
+            for (let idx = 0; idx < labels.length; idx++) {
+                labels[idx].options.rotation = angle;
+                labels[idx].reflow(new Box());
             }
 
             return true;
         }
-    };
+    }
 
-    Axis.prototype.arrangeTitle = function arrangeTitle () {
-        var ref = this;
-        var options = ref.options;
-        var title = ref.title;
-        var mirror = options.labels.mirror;
-        var vertical = options.vertical;
+    arrangeTitle() {
+        const { options, title } = this;
+        const mirror = options.labels.mirror;
+        const vertical = options.vertical;
 
         if (title) {
             if (vertical) {
@@ -678,40 +644,38 @@ var Axis = (function (ChartElement) {
 
             title.reflow(this.box);
         }
-    };
-
-    Axis.prototype.arrangeNotes = function arrangeNotes () {
-        var this$1 = this;
+    }
 
-        for (var idx = 0; idx < this.notes.length; idx++) {
-            var item = this$1.notes[idx];
-            var value = item.options.value;
-            var slot = (void 0);
+    arrangeNotes() {
+        for (let idx = 0; idx < this.notes.length; idx++) {
+            const item = this.notes[idx];
+            const value = item.options.value;
+            let slot;
 
             if (defined(value)) {
-                if (this$1.shouldRenderNote(value)) {
+                if (this.shouldRenderNote(value)) {
                     item.show();
                 } else {
                     item.hide();
                 }
 
-                slot = this$1.noteSlot(value);
+                slot = this.noteSlot(value);
             } else {
                 item.hide();
             }
 
-            item.reflow(slot || this$1.lineBox());
+            item.reflow(slot || this.lineBox());
         }
-    };
+    }
 
-    Axis.prototype.noteSlot = function noteSlot (value) {
+    noteSlot(value) {
         return this.getSlot(value);
-    };
+    }
 
-    Axis.prototype.alignTo = function alignTo (secondAxis) {
-        var lineBox = secondAxis.lineBox();
-        var vertical = this.options.vertical;
-        var pos = vertical ? Y : X;
+    alignTo(secondAxis) {
+        const lineBox = secondAxis.lineBox();
+        const vertical = this.options.vertical;
+        const pos = vertical ? Y : X;
 
         this.box.snapTo(lineBox, pos);
         if (vertical) {
@@ -721,27 +685,25 @@ var Axis = (function (ChartElement) {
         }
         this.box[pos + 1] -= this.lineBox()[pos + 1] - lineBox[pos + 1];
         this.box[pos + 2] -= this.lineBox()[pos + 2] - lineBox[pos + 2];
-    };
-
-    Axis.prototype.axisLabelText = function axisLabelText (value, options, context) {
-        var this$1 = this;
+    }
 
-        var text;
-        var tmpl = getTemplate(options);
-        var defaultText = function () {
+    axisLabelText(value, options, context) {
+        let text;
+        const tmpl = getTemplate(options);
+        const defaultText = () => {
             if (!options.format) {
                 return value;
             }
 
-            return this$1.chartService.format.localeAuto(
+            return this.chartService.format.localeAuto(
                 options.format, [ value ], options.culture
             );
         };
 
         if (tmpl) {
-            var templateContext = Object.assign({}, context, {
+            const templateContext = Object.assign({}, context, {
                 get text() { return defaultText(); },
-                value: value,
+                value,
                 format: options.format,
                 culture: options.culture
             });
@@ -752,29 +714,29 @@ var Axis = (function (ChartElement) {
         }
 
         return text;
-    };
+    }
 
-    Axis.prototype.slot = function slot (from , to, limit) {
-        var slot = this.getSlot(from, to, limit);
+    slot(from , to, limit) {
+        const slot = this.getSlot(from, to, limit);
         if (slot) {
             return slot.toRect();
         }
-    };
+    }
 
-    Axis.prototype.contentBox = function contentBox () {
-        var box = this.box.clone();
-        var labels = this.labels;
+    contentBox() {
+        const box = this.box.clone();
+        const labels = this.labels;
         if (labels.length) {
-            var axis = this.options.vertical ? Y : X;
+            const axis = this.options.vertical ? Y : X;
             if (this.chartService.isPannable(axis)) {
-                var offset = this.maxLabelOffset();
+                const offset = this.maxLabelOffset();
                 box[axis + 1] -= offset.start;
                 box[axis + 2] += offset.end;
             } else {
                 if (labels[0].options.visible) {
                     box.wrap(labels[0].box);
                 }
-                var lastLabel = labels[labels.length - 1];
+                const lastLabel = labels[labels.length - 1];
                 if (lastLabel.options.visible) {
                     box.wrap(lastLabel.box);
                 }
@@ -782,27 +744,23 @@ var Axis = (function (ChartElement) {
         }
 
         return box;
-    };
-
-    Axis.prototype.maxLabelOffset = function maxLabelOffset () {
-        var this$1 = this;
-
-        var ref = this.options;
-        var vertical = ref.vertical;
-        var reverse = ref.reverse;
-        var labelsBetweenTicks = this.labelsBetweenTicks();
-        var tickPositions = this.getLabelsTickPositions();
-        var offsetField = vertical ? Y : X;
-        var labels = this.labels;
-        var startPosition = reverse ? 1 : 0;
-        var endPosition = reverse ? 0 : 1;
-        var maxStartOffset = 0;
-        var maxEndOffset = 0;
-
-        for (var idx = 0; idx < labels.length; idx++) {
-            var label = labels[idx];
-            var tickIx = this$1.labelTickIndex(label);
-            var startTick = (void 0), endTick = (void 0);
+    }
+
+    maxLabelOffset() {
+        const { vertical, reverse } = this.options;
+        const labelsBetweenTicks = this.labelsBetweenTicks();
+        const tickPositions = this.getLabelsTickPositions();
+        const offsetField = vertical ? Y : X;
+        const labels = this.labels;
+        const startPosition = reverse ? 1 : 0;
+        const endPosition = reverse ? 0 : 1;
+        let maxStartOffset = 0;
+        let maxEndOffset = 0;
+
+        for (let idx = 0; idx < labels.length; idx++) {
+            const label = labels[idx];
+            const tickIx = this.labelTickIndex(label);
+            let startTick, endTick;
 
             if (labelsBetweenTicks) {
                 startTick = tickPositions[tickIx + startPosition];
@@ -819,10 +777,10 @@ var Axis = (function (ChartElement) {
             start: maxStartOffset,
             end: maxEndOffset
         };
-    };
+    }
 
-    Axis.prototype.limitRange = function limitRange (from, to, min, max, offset) {
-        var options = this.options;
+    limitRange(from, to, min, max, offset) {
+        const options = this.options;
 
         if ((from < min && offset < 0 && (!defined(options.min) || options.min <= min)) || (max < to && offset > 0 && (!defined(options.max) || max <= options.max))) {
             return null;
@@ -835,9 +793,9 @@ var Axis = (function (ChartElement) {
             };
         }
 
-        var rangeSize = to - from;
-        var minValue = from;
-        var maxValue = to;
+        const rangeSize = to - from;
+        let minValue = from;
+        let maxValue = to;
 
         if (from < min && offset < 0) {
             minValue = limitValue(from, min, max);
@@ -851,73 +809,65 @@ var Axis = (function (ChartElement) {
             min: minValue,
             max: maxValue
         };
-    };
+    }
 
-    Axis.prototype.valueRange = function valueRange () {
+    valueRange() {
         return {
             min: this.seriesMin,
             max: this.seriesMax
         };
-    };
+    }
 
-    Axis.prototype.lineDir = function lineDir () {
+    lineDir() {
         /*
          * Axis line direction:
          *   * Vertical: up.
          *   * Horizontal: right.
          */
 
-        var ref = this.options;
-        var vertical = ref.vertical;
-        var reverse = ref.reverse;
+        const { vertical, reverse } = this.options;
         return (vertical ? -1 : 1) * (reverse ? -1 : 1);
-    };
-
-    Axis.prototype.lineInfo = function lineInfo () {
-        var ref = this.options;
-        var vertical = ref.vertical;
-        var lineBox = this.lineBox();
-        var lineSize = vertical ? lineBox.height() : lineBox.width();
-        var axis = vertical ? Y : X;
-        var axisDir = this.lineDir();
-        var startEdge = axisDir === 1 ? 1 : 2;
-        var axisOrigin = axis + startEdge.toString();
-        var lineStart = lineBox[axisOrigin];
+    }
+
+    lineInfo() {
+        const { vertical } = this.options;
+        const lineBox = this.lineBox();
+        const lineSize = vertical ? lineBox.height() : lineBox.width();
+        const axis = vertical ? Y : X;
+        const axisDir = this.lineDir();
+        const startEdge = axisDir === 1 ? 1 : 2;
+        const axisOrigin = axis + startEdge.toString();
+        const lineStart = lineBox[axisOrigin];
 
         return {
-            axis: axis,
-            axisOrigin: axisOrigin,
-            axisDir: axisDir,
-            lineBox: lineBox,
-            lineSize: lineSize,
-            lineStart: lineStart
+            axis,
+            axisOrigin,
+            axisDir,
+            lineBox,
+            lineSize,
+            lineStart
         };
-    };
-
-    Axis.prototype.pointOffset = function pointOffset (point) {
-        var ref = this.lineInfo();
-        var axis = ref.axis;
-        var axisDir = ref.axisDir;
-        var axisOrigin = ref.axisOrigin;
-        var lineBox = ref.lineBox;
-        var lineSize = ref.lineSize;
-        var relative = axisDir > 0 ? point[axis] - lineBox[axisOrigin] : lineBox[axisOrigin] - point[axis];
-        var offset = relative / lineSize;
+    }
+
+    pointOffset(point) {
+        const { axis, axisDir, axisOrigin, lineBox, lineSize } = this.lineInfo();
+        const relative = axisDir > 0 ? point[axis] - lineBox[axisOrigin] : lineBox[axisOrigin] - point[axis];
+        const offset = relative / lineSize;
 
         return offset;
-    };
+    }
 
     // Computes the axis range change (delta) for a given scale factor.
     // The delta is subtracted from the axis range:
     //   * delta > 0 reduces the axis range (zoom-in)
     //   * delta < 0 expands the axis range (zoom-out)
-    Axis.prototype.scaleToDelta = function scaleToDelta (rawScale, range) {
+    scaleToDelta(rawScale, range) {
         // Scale >= 1 would result in axis range of 0.
         // Scale <= -1 would reverse the scale direction.
-        var MAX_SCALE = 0.999;
-        var scale = limitValue(rawScale, -MAX_SCALE, MAX_SCALE);
+        const MAX_SCALE = 0.999;
+        const scale = limitValue(rawScale, -MAX_SCALE, MAX_SCALE);
 
-        var delta;
+        let delta;
         if (scale > 0) {
             delta = range * Math.min(1, scale);
         } else {
@@ -925,18 +875,16 @@ var Axis = (function (ChartElement) {
         }
 
         return delta;
-    };
+    }
 
-    Axis.prototype.labelsBetweenTicks = function labelsBetweenTicks () {
+    labelsBetweenTicks() {
         return !this.options.justified;
-    };
+    }
 
     //add legacy fields to the options that are no longer generated by default
-    Axis.prototype.prepareUserOptions = function prepareUserOptions () {
-    };
-
-    return Axis;
-}(ChartElement));
+    prepareUserOptions() {
+    }
+}
 
 setDefaultOptions(Axis, {
     labels: {