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

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

@@ -5,13 +5,13 @@ import { BLACK, COORD_PRECISION, DEFAULT_PRECISION, X, Y } from '../common/const
 import { defined, isNumber, last, limitValue, round, setDefaultOptions, valueOrDefault, HashMap } from '../common';
 import { dateEquals } from '../date-utils';
 
-var MIN_CATEGORY_POINTS_RANGE = 0.01;
-var MIN_CATEGORY_RANGE = 0.1;
+const MIN_CATEGORY_POINTS_RANGE = 0.01;
+const MIN_CATEGORY_RANGE = 0.1;
 
 function indexOf(value, arr) {
     if (value instanceof Date) {
-        var length = arr.length;
-        for (var idx = 0; idx < length; idx++) {
+        const length = arr.length;
+        for (let idx = 0; idx < length; idx++) {
             if (dateEquals(arr[idx], value)) {
                 return idx;
             }
@@ -23,41 +23,33 @@ function indexOf(value, arr) {
     return arr.indexOf(value);
 }
 
-var CategoryAxis = (function (Axis) {
-    function CategoryAxis () {
-        Axis.apply(this, arguments);
-    }
-
-    if ( Axis ) CategoryAxis.__proto__ = Axis;
-    CategoryAxis.prototype = Object.create( Axis && Axis.prototype );
-    CategoryAxis.prototype.constructor = CategoryAxis;
-
-    CategoryAxis.prototype.initFields = function initFields () {
+class CategoryAxis extends Axis {
+    initFields() {
         this._ticks = {};
-    };
+    }
 
-    CategoryAxis.prototype.categoriesHash = function categoriesHash () {
+    categoriesHash() {
         return "";
-    };
+    }
 
-    CategoryAxis.prototype.clone = function clone () {
-        var copy = new CategoryAxis(Object.assign({}, this.options, {
+    clone() {
+        const copy = new CategoryAxis(Object.assign({}, this.options, {
             categories: this.options.srcCategories
         }), this.chartService);
         copy.createLabels();
 
         return copy;
-    };
+    }
 
-    CategoryAxis.prototype.initUserOptions = function initUserOptions (options) {
-        var categories = options.categories || [];
-        var definedMin = defined(options.min);
-        var definedMax = defined(options.max);
+    initUserOptions(options) {
+        const categories = options.categories || [];
+        const definedMin = defined(options.min);
+        const definedMax = defined(options.max);
         options.srcCategories = options.categories = categories;
 
         if ((definedMin || definedMax) && categories.length) {
-            var min = definedMin ? Math.floor(options.min) : 0;
-            var max;
+            const min = definedMin ? Math.floor(options.min) : 0;
+            let max;
 
             if (definedMax) {
                 max = options.justified ? Math.floor(options.max) + 1 : Math.ceil(options.max);
@@ -69,13 +61,13 @@ var CategoryAxis = (function (Axis) {
         }
 
         return options;
-    };
+    }
 
-    CategoryAxis.prototype.rangeIndices = function rangeIndices () {
-        var options = this.options;
-        var length = options.categories.length || 1;
-        var min = isNumber(options.min) ? options.min % 1 : 0;
-        var max;
+    rangeIndices() {
+        const options = this.options;
+        const length = options.categories.length || 1;
+        const min = isNumber(options.min) ? options.min % 1 : 0;
+        let max;
 
         if (isNumber(options.max) && options.max % 1 !== 0 && options.max < this.totalRange().max) {
             max = length - (1 - options.max % 1);
@@ -87,35 +79,33 @@ var CategoryAxis = (function (Axis) {
             min: min,
             max: max
         };
-    };
+    }
 
-    CategoryAxis.prototype.range = function range () {
-        var options = this.options;
-        var min = isNumber(options.min) ? options.min : 0;
-        var max = isNumber(options.max) ? options.max : this.totalRange().max;
+    range() {
+        const options = this.options;
+        const min = isNumber(options.min) ? options.min : 0;
+        const max = isNumber(options.max) ? options.max : this.totalRange().max;
 
         return {
             min: min,
             max: max
         };
-    };
+    }
 
-    CategoryAxis.prototype.roundedRange = function roundedRange () {
+    roundedRange() {
         return this.range();
-    };
+    }
 
-    CategoryAxis.prototype.totalRange = function totalRange () {
-        var options = this.options;
+    totalRange() {
+        const options = this.options;
         return { min: 0, max: Math.max(this._seriesMax || 0, options.srcCategories.length) - (options.justified ? 1 : 0) };
-    };
+    }
 
-    CategoryAxis.prototype.scaleOptions = function scaleOptions () {
-        var ref = this.rangeIndices();
-        var min = ref.min;
-        var max = ref.max;
-        var lineBox = this.lineBox();
-        var size = this.options.vertical ? lineBox.height() : lineBox.width();
-        var scale = size / ((max - min) || 1);
+    scaleOptions() {
+        const { min, max } = this.rangeIndices();
+        const lineBox = this.lineBox();
+        const size = this.options.vertical ? lineBox.height() : lineBox.width();
+        const scale = size / ((max - min) || 1);
 
         return {
             scale: scale * (this.options.reverse ? -1 : 1),
@@ -123,24 +113,22 @@ var CategoryAxis = (function (Axis) {
             min: min,
             max: max
         };
-    };
+    }
 
-    CategoryAxis.prototype.arrangeLabels = function arrangeLabels () {
-        Axis.prototype.arrangeLabels.call(this);
+    arrangeLabels() {
+        super.arrangeLabels();
         this.hideOutOfRangeLabels();
-    };
+    }
 
-    CategoryAxis.prototype.hideOutOfRangeLabels = function hideOutOfRangeLabels () {
-        var ref = this;
-        var box = ref.box;
-        var labels = ref.labels;
+    hideOutOfRangeLabels() {
+        const { box, labels } = this;
 
         if (labels.length > 0) {
-            var valueAxis = this.options.vertical ? Y : X;
-            var start = box[valueAxis + 1];
-            var end = box[valueAxis + 2];
-            var firstLabel = labels[0];
-            var lastLabel = last(labels);
+            const valueAxis = this.options.vertical ? Y : X;
+            const start = box[valueAxis + 1];
+            const end = box[valueAxis + 2];
+            const firstLabel = labels[0];
+            const lastLabel = last(labels);
 
             if (firstLabel.box[valueAxis + 1] > end || firstLabel.box[valueAxis + 2] < start) {
                 firstLabel.options.visible = false;
@@ -149,27 +137,25 @@ var CategoryAxis = (function (Axis) {
                 lastLabel.options.visible = false;
             }
         }
-    };
+    }
 
-    CategoryAxis.prototype.getMajorTickPositions = function getMajorTickPositions () {
+    getMajorTickPositions() {
         return this.getTicks().majorTicks;
-    };
+    }
 
-    CategoryAxis.prototype.getMinorTickPositions = function getMinorTickPositions () {
+    getMinorTickPositions() {
         return this.getTicks().minorTicks;
-    };
+    }
 
-    CategoryAxis.prototype.getLabelsTickPositions = function getLabelsTickPositions () {
+    getLabelsTickPositions() {
         return this.getTicks().labelTicks;
-    };
+    }
 
-    CategoryAxis.prototype.tickIndices = function tickIndices (stepSize) {
-        var ref = this.rangeIndices();
-        var min = ref.min;
-        var max = ref.max;
-        var limit = Math.ceil(max);
-        var current = Math.floor(min);
-        var indices = [];
+    tickIndices(stepSize) {
+        const { min, max } = this.rangeIndices();
+        const limit = Math.ceil(max);
+        let current = Math.floor(min);
+        const indices = [];
 
         while (current <= limit) {
             indices.push(current);
@@ -177,36 +163,31 @@ var CategoryAxis = (function (Axis) {
         }
 
         return indices;
-    };
-
-    CategoryAxis.prototype.getTickPositions = function getTickPositions (stepSize) {
-        var ref = this.options;
-        var vertical = ref.vertical;
-        var reverse = ref.reverse;
-        var ref$1 = this.scaleOptions();
-        var scale = ref$1.scale;
-        var box = ref$1.box;
-        var min = ref$1.min;
-        var pos = box[(vertical ? Y : X) + (reverse ? 2 : 1)];
-        var indices = this.tickIndices(stepSize);
-        var positions = [];
-
-        for (var idx = 0; idx < indices.length; idx++) {
+    }
+
+    getTickPositions(stepSize) {
+        const { vertical, reverse } = this.options;
+        const { scale, box, min } = this.scaleOptions();
+        const pos = box[(vertical ? Y : X) + (reverse ? 2 : 1)];
+        const indices = this.tickIndices(stepSize);
+        const positions = [];
+
+        for (let idx = 0; idx < indices.length; idx++) {
             positions.push(pos + round(scale * (indices[idx] - min), COORD_PRECISION));
         }
 
         return positions;
-    };
+    }
 
-    CategoryAxis.prototype.getTicks = function getTicks () {
-        var options = this.options;
-        var cache = this._ticks;
-        var range = this.rangeIndices();
-        var lineBox = this.lineBox();
-        var hash = lineBox.getHash() + range.min + "," + range.max + options.reverse + options.justified;
+    getTicks() {
+        const options = this.options;
+        const cache = this._ticks;
+        const range = this.rangeIndices();
+        const lineBox = this.lineBox();
+        const hash = lineBox.getHash() + range.min + "," + range.max + options.reverse + options.justified;
 
         if (cache._hash !== hash) {
-            var hasMinor = options.minorTicks.visible || options.minorGridLines.visible;
+            const hasMinor = options.minorTicks.visible || options.minorGridLines.visible;
             cache._hash = hash;
             cache.labelTicks = this.getTickPositions(1);
             cache.majorTicks = this.filterOutOfRangePositions(cache.labelTicks, lineBox);
@@ -214,91 +195,82 @@ var CategoryAxis = (function (Axis) {
         }
 
         return cache;
-    };
+    }
 
-    CategoryAxis.prototype.filterOutOfRangePositions = function filterOutOfRangePositions (positions, lineBox) {
+    filterOutOfRangePositions(positions, lineBox) {
         if (!positions.length) {
             return positions;
         }
 
-        var axis = this.options.vertical ? Y : X;
-        var inRange = function (position) { return lineBox[axis + 1] <= position && position <= lineBox[axis + 2]; };
+        const axis = this.options.vertical ? Y : X;
+        const inRange = (position) => lineBox[axis + 1] <= position && position <= lineBox[axis + 2];
 
-        var end = positions.length - 1;
-        var startIndex = 0;
+        const end = positions.length - 1;
+        let startIndex = 0;
         while (!inRange(positions[startIndex]) && startIndex <= end) {
             startIndex++;
         }
 
-        var endIndex = end;
+        let endIndex = end;
 
         while (!inRange(positions[endIndex]) && endIndex >= 0) {
             endIndex--;
         }
 
         return positions.slice(startIndex, endIndex + 1);
-    };
-
-    CategoryAxis.prototype.lineInfo = function lineInfo () {
-        var ref = this.options;
-        var vertical = ref.vertical;
-        var reverse = ref.reverse;
-        var lineBox = this.lineBox();
-        var lineSize = vertical ? lineBox.height() : lineBox.width();
-        var axis = vertical ? Y : X;
-        var axisDir = reverse ? -1 : 1;
-        var startEdge = axisDir === 1 ? 1 : 2;
-        var axisOrigin = axis + startEdge.toString();
-        var lineStart = lineBox[axisOrigin];
+    }
+
+    lineInfo() {
+        const { vertical, reverse } = this.options;
+        const lineBox = this.lineBox();
+        const lineSize = vertical ? lineBox.height() : lineBox.width();
+        const axis = vertical ? Y : X;
+        const axisDir = reverse ? -1 : 1;
+        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
         };
-    };
+    }
 
-    CategoryAxis.prototype.lineDir = function lineDir () {
+    lineDir() {
         /*
          *  Category axis line direction:
          *    * Vertical: down.
          *    * Horizontal: right.
          */
 
-        var ref = this.options;
-        var reverse = ref.reverse;
+        const { reverse } = this.options;
         return reverse ? -1 : 1;
-    };
+    }
 
     // TODO: Rename to slotBox, valueSlot, slotByIndex?
-    CategoryAxis.prototype.getSlot = function getSlot (from, to, limit) {
-        var options = this.options;
-        var reverse = options.reverse;
-        var justified = options.justified;
-        var ref = this.scaleOptions();
-        var scale = ref.scale;
-        var box = ref.box;
-        var min = ref.min;
-        var ref$1 = this.lineInfo();
-        var valueAxis = ref$1.axis;
-        var lineStart = ref$1.lineStart;
-
-        var slotBox = box.clone();
-        var singleSlot = !defined(to);
-
-        var start = valueOrDefault(from, 0);
-        var end = valueOrDefault(to, start);
+    getSlot(from, to, limit) {
+        const options = this.options;
+        const { reverse, justified } = options;
+        const { scale, box, min } = this.scaleOptions();
+        const { axis: valueAxis, lineStart } = this.lineInfo();
+
+        const slotBox = box.clone();
+        const singleSlot = !defined(to);
+
+        const start = valueOrDefault(from, 0);
+        let end = valueOrDefault(to, start);
         end = Math.max(end - 1, start);
 
         // Fixes transient bug caused by iOS 6.0 JIT
         // (one can never be too sure)
         end = Math.max(start, end);
 
-        var p1 = lineStart + (start - min) * scale;
-        var p2 = lineStart + (end + 1 - min) * scale;
+        let p1 = lineStart + (start - min) * scale;
+        let p2 = lineStart + (end + 1 - min) * scale;
 
         if (singleSlot && justified) {
             p2 = p1;
@@ -313,24 +285,24 @@ var CategoryAxis = (function (Axis) {
         slotBox[valueAxis + 2] = reverse ? p1 : p2;
 
         return slotBox;
-    };
+    }
 
-    CategoryAxis.prototype.limitSlot = function limitSlot (slot) {
-        var vertical = this.options.vertical;
-        var valueAxis = vertical ? Y : X;
-        var lineBox = this.lineBox();
-        var limittedSlot = slot.clone();
+    limitSlot(slot) {
+        const vertical = this.options.vertical;
+        const valueAxis = vertical ? Y : X;
+        const lineBox = this.lineBox();
+        const limittedSlot = slot.clone();
 
         limittedSlot[valueAxis + 1] = limitValue(slot[valueAxis + 1], lineBox[valueAxis + 1], lineBox[valueAxis + 2]);
         limittedSlot[valueAxis + 2] = limitValue(slot[valueAxis + 2], lineBox[valueAxis + 1], lineBox[valueAxis + 2]);
 
         return limittedSlot;
-    };
+    }
 
-    CategoryAxis.prototype.slot = function slot (from, to, limit) {
-        var min = Math.floor(this.options.min || 0);
-        var start = from;
-        var end = to;
+    slot(from, to, limit) {
+        const min = Math.floor(this.options.min || 0);
+        let start = from;
+        let end = to;
 
         if (typeof start === "string") {
             start = this.categoryIndex(start);
@@ -344,31 +316,24 @@ var CategoryAxis = (function (Axis) {
             end -= min;
         }
 
-        return Axis.prototype.slot.call(this, start, end, limit);
-    };
-
-    CategoryAxis.prototype.pointCategoryIndex = function pointCategoryIndex (point) {
-        var ref = this.options;
-        var reverse = ref.reverse;
-        var justified = ref.justified;
-        var vertical = ref.vertical;
-        var valueAxis = vertical ? Y : X;
-        var ref$1 = this.scaleOptions();
-        var scale = ref$1.scale;
-        var box = ref$1.box;
-        var min = ref$1.min;
-        var max = ref$1.max;
-        var startValue = reverse ? max : min;
-        var lineStart = box[valueAxis + 1];
-        var lineEnd = box[valueAxis + 2];
-        var pos = point[valueAxis];
+        return super.slot(start, end, limit);
+    }
+
+    pointCategoryIndex(point) {
+        const { reverse, justified, vertical } = this.options;
+        const valueAxis = vertical ? Y : X;
+        const { scale, box, min, max } = this.scaleOptions();
+        const startValue = reverse ? max : min;
+        const lineStart = box[valueAxis + 1];
+        const lineEnd = box[valueAxis + 2];
+        const pos = point[valueAxis];
 
         if (pos < lineStart || pos > lineEnd) {
             return null;
         }
 
-        var value = startValue + (pos - lineStart) / scale;
-        var diff = value % 1;
+        let value = startValue + (pos - lineStart) / scale;
+        const diff = value % 1;
 
         if (justified) {
             value = Math.round(value);
@@ -377,55 +342,55 @@ var CategoryAxis = (function (Axis) {
         }
 
         return Math.floor(value);
-    };
+    }
 
-    CategoryAxis.prototype.getCategory = function getCategory (point) {
-        var index = this.pointCategoryIndex(point);
+    getCategory(point) {
+        const index = this.pointCategoryIndex(point);
 
         if (index === null) {
             return null;
         }
 
         return this.options.categories[index];
-    };
+    }
 
-    CategoryAxis.prototype.categoryIndex = function categoryIndex (value) {
+    categoryIndex(value) {
         return this.totalIndex(value) - Math.floor(this.options.min || 0);
-    };
+    }
 
-    CategoryAxis.prototype.categoryAt = function categoryAt (index, total) {
-        var options = this.options;
+    categoryAt(index, total) {
+        const options = this.options;
 
         return (total ? options.srcCategories : options.categories)[index];
-    };
+    }
 
-    CategoryAxis.prototype.categoriesCount = function categoriesCount () {
+    categoriesCount() {
         return (this.options.categories || []).length;
-    };
+    }
 
-    CategoryAxis.prototype.translateRange = function translateRange (delta) {
-        var options = this.options;
-        var lineBox = this.lineBox();
-        var size = options.vertical ? lineBox.height() : lineBox.width();
-        var range = options.categories.length;
-        var scale = size / range;
-        var offset = round(delta / scale, DEFAULT_PRECISION);
+    translateRange(delta) {
+        const options = this.options;
+        const lineBox = this.lineBox();
+        const size = options.vertical ? lineBox.height() : lineBox.width();
+        const range = options.categories.length;
+        const scale = size / range;
+        const offset = round(delta / scale, DEFAULT_PRECISION);
 
         return {
             min: offset,
             max: range + offset
         };
-    };
-
-    CategoryAxis.prototype.scaleRange = function scaleRange (scale, cursor) {
-        var position = Math.abs(this.pointOffset(cursor));
-        var rangeIndices = this.limitedRangeIndices();
-        var range = rangeIndices.max - rangeIndices.min;
-        var delta = this.scaleToDelta(scale, range);
-        var minDelta = position * delta;
-        var maxDelta = (1 - position) * delta;
-        var min = rangeIndices.min + minDelta;
-        var max = rangeIndices.max - maxDelta;
+    }
+
+    scaleRange(scale, cursor) {
+        const position = Math.abs(this.pointOffset(cursor));
+        const rangeIndices = this.limitedRangeIndices();
+        const range = rangeIndices.max - rangeIndices.min;
+        const delta = this.scaleToDelta(scale, range);
+        const minDelta = position * delta;
+        const maxDelta = (1 - position) * delta;
+        const min = rangeIndices.min + minDelta;
+        let max = rangeIndices.max - maxDelta;
 
         if (max - min < MIN_CATEGORY_RANGE) {
             max = min + MIN_CATEGORY_RANGE;
@@ -435,34 +400,29 @@ var CategoryAxis = (function (Axis) {
             min: min,
             max: max
         };
-    };
+    }
 
-    CategoryAxis.prototype.zoomRange = function zoomRange (scale, cursor) {
-        var ref = this.totalRange();
-        var totalMin = ref.min;
-        var totalMax = ref.max;
-        var range = this.scaleRange(scale, cursor);
+    zoomRange(scale, cursor) {
+        const { min: totalMin, max: totalMax } = this.totalRange();
+        const range = this.scaleRange(scale, cursor);
 
         return {
             min: limitValue(range.min, totalMin, totalMax),
             max: limitValue(range.max, totalMin, totalMax)
         };
-    };
+    }
 
-    CategoryAxis.prototype.labelsCount = function labelsCount () {
-        var labelsRange = this.labelsRange();
+    labelsCount() {
+        const labelsRange = this.labelsRange();
 
         return labelsRange.max - labelsRange.min;
-    };
+    }
 
-    CategoryAxis.prototype.labelsRange = function labelsRange () {
-        var options = this.options;
-        var justified = options.justified;
-        var labelOptions = options.labels;
-        var ref = this.limitedRangeIndices(true);
-        var min = ref.min;
-        var max = ref.max;
-        var start = Math.floor(min);
+    labelsRange() {
+        const options = this.options;
+        const { justified, labels: labelOptions } = options;
+        let { min, max } = this.limitedRangeIndices(true);
+        const start = Math.floor(min);
 
         if (!justified) {
             min = Math.floor(min);
@@ -472,7 +432,7 @@ var CategoryAxis = (function (Axis) {
             max = Math.floor(max);
         }
 
-        var skip;
+        let skip;
 
         if (min > labelOptions.skip) {
             skip = labelOptions.skip + labelOptions.step * Math.ceil((min - labelOptions.skip) / labelOptions.step);
@@ -484,84 +444,77 @@ var CategoryAxis = (function (Axis) {
             min: skip - start,
             max: (options.categories.length ? max + (justified ? 1 : 0) : 0) - start
         };
-    };
+    }
 
-    CategoryAxis.prototype.createAxisLabel = function createAxisLabel (index, labelOptions, labelContext) {
-        var options = this.options;
-        var dataItem = options.dataItems ? options.dataItems[index] : null;
-        var category = valueOrDefault(options.categories[index], "");
+    createAxisLabel(index, labelOptions, labelContext) {
+        const options = this.options;
+        const dataItem = options.dataItems ? options.dataItems[index] : null;
+        const category = valueOrDefault(options.categories[index], "");
 
         labelContext.dataItem = dataItem;
-        var text = this.axisLabelText(category, labelOptions, labelContext);
+        const text = this.axisLabelText(category, labelOptions, labelContext);
 
         return new AxisLabel(category, text, index, dataItem, labelOptions);
-    };
+    }
 
-    CategoryAxis.prototype.shouldRenderNote = function shouldRenderNote (value) {
-        var range = this.limitedRangeIndices();
+    shouldRenderNote(value) {
+        const range = this.limitedRangeIndices();
 
         return Math.floor(range.min) <= value && value <= Math.ceil(range.max);
-    };
+    }
 
-    CategoryAxis.prototype.noteSlot = function noteSlot (value) {
-        var options = this.options;
-        var index = value - Math.floor(options.min || 0);
+    noteSlot(value) {
+        const options = this.options;
+        const index = value - Math.floor(options.min || 0);
         return this.getSlot(index);
-    };
+    }
 
-    CategoryAxis.prototype.arrangeNotes = function arrangeNotes () {
-        Axis.prototype.arrangeNotes.call(this);
+    arrangeNotes() {
+        super.arrangeNotes();
         this.hideOutOfRangeNotes();
-    };
+    }
 
-    CategoryAxis.prototype.hideOutOfRangeNotes = function hideOutOfRangeNotes () {
-        var ref = this;
-        var notes = ref.notes;
-        var box = ref.box;
+    hideOutOfRangeNotes() {
+        const { notes, box } = this;
         if (notes && notes.length) {
-            var valueAxis = this.options.vertical ? Y : X;
-            var start = box[valueAxis + 1];
-            var end = box[valueAxis + 2];
+            const valueAxis = this.options.vertical ? Y : X;
+            const start = box[valueAxis + 1];
+            const end = box[valueAxis + 2];
 
-            for (var idx = 0; idx < notes.length; idx++) {
-                var note = notes[idx];
+            for (let idx = 0; idx < notes.length; idx++) {
+                const note = notes[idx];
                 if (note.box && (end < note.box[valueAxis + 1] || note.box[valueAxis + 2] < start)) {
                     note.hide();
                 }
             }
         }
-    };
+    }
 
-    CategoryAxis.prototype.pan = function pan (delta) {
-        var range = this.limitedRangeIndices(true);
-        var ref = this.scaleOptions();
-        var scale = ref.scale;
-        var offset = round(delta / scale, DEFAULT_PRECISION);
-        var totalRange = this.totalRange();
-        var min = range.min + offset;
-        var max = range.max + offset;
+    pan(delta) {
+        const range = this.limitedRangeIndices(true);
+        const { scale } = this.scaleOptions();
+        const offset = round(delta / scale, DEFAULT_PRECISION);
+        const totalRange = this.totalRange();
+        const min = range.min + offset;
+        const max = range.max + offset;
 
         return this.limitRange(min, max, 0, totalRange.max, offset);
-    };
-
-    CategoryAxis.prototype.pointsRange = function pointsRange (start, end) {
-        var ref = this.options;
-        var reverse = ref.reverse;
-        var vertical = ref.vertical;
-        var valueAxis = vertical ? Y : X;
-        var range = this.limitedRangeIndices(true);
-        var ref$1 = this.scaleOptions();
-        var scale = ref$1.scale;
-        var box = ref$1.box;
-        var lineStart = box[valueAxis + (reverse ? 2 : 1)];
-
-        var diffStart = start[valueAxis] - lineStart;
-        var diffEnd = end[valueAxis] - lineStart;
-
-        var min = range.min + diffStart / scale;
-        var max = range.min + diffEnd / scale;
-        var rangeMin = Math.min(min, max);
-        var rangeMax = Math.max(min, max);
+    }
+
+    pointsRange(start, end) {
+        const { reverse, vertical } = this.options;
+        const valueAxis = vertical ? Y : X;
+        const range = this.limitedRangeIndices(true);
+        const { scale, box } = this.scaleOptions();
+        const lineStart = box[valueAxis + (reverse ? 2 : 1)];
+
+        const diffStart = start[valueAxis] - lineStart;
+        const diffEnd = end[valueAxis] - lineStart;
+
+        const min = range.min + diffStart / scale;
+        const max = range.min + diffEnd / scale;
+        const rangeMin = Math.min(min, max);
+        const rangeMax = Math.max(min, max);
 
         if (rangeMax - rangeMin >= MIN_CATEGORY_POINTS_RANGE) {
             return {
@@ -569,29 +522,29 @@ var CategoryAxis = (function (Axis) {
                 max: rangeMax
             };
         }
-    };
+    }
 
-    CategoryAxis.prototype.valueRange = function valueRange () {
+    valueRange() {
         return this.range();
-    };
+    }
 
-    CategoryAxis.prototype.totalIndex = function totalIndex (value) {
-        var options = this.options;
-        var index = this._categoriesMap ?
+    totalIndex(value) {
+        const options = this.options;
+        const index = this._categoriesMap ?
             this._categoriesMap.get(value) : indexOf(value, options.srcCategories);
 
         return index;
-    };
+    }
 
-    CategoryAxis.prototype.currentRangeIndices = function currentRangeIndices () {
-        var options = this.options;
-        var min = 0;
+    currentRangeIndices() {
+        const options = this.options;
+        let min = 0;
 
         if (isNumber(options.min)) {
             min = Math.floor(options.min);
         }
 
-        var max;
+        let max;
         if (isNumber(options.max)) {
             max = options.justified ? Math.floor(options.max) : Math.ceil(options.max) - 1;
         } else {
@@ -602,12 +555,12 @@ var CategoryAxis = (function (Axis) {
             min: min,
             max: max
         };
-    };
+    }
 
-    CategoryAxis.prototype.limitedRangeIndices = function limitedRangeIndices (totalLimit) {
-        var options = this.options;
-        var min = isNumber(options.min) ? options.min : 0;
-        var max;
+    limitedRangeIndices(totalLimit) {
+        const options = this.options;
+        let min = isNumber(options.min) ? options.min : 0;
+        let max;
 
         if (isNumber(options.max)) {
             max = options.max;
@@ -618,7 +571,7 @@ var CategoryAxis = (function (Axis) {
         }
 
         if (totalLimit) {
-            var totalRange = this.totalRange();
+            const totalRange = this.totalRange();
             min = limitValue(min, 0, totalRange.max);
             max = limitValue(max, 0, totalRange.max);
         }
@@ -627,31 +580,29 @@ var CategoryAxis = (function (Axis) {
             min: min,
             max: max
         };
-    };
+    }
 
-    CategoryAxis.prototype.totalRangeIndices = function totalRangeIndices () {
+    totalRangeIndices() {
         return {
             min: 0,
             max: this.totalRange().max || 1
         };
-    };
+    }
 
-    CategoryAxis.prototype.indexCategories = function indexCategories () {
+    indexCategories() {
         if (!this._categoriesMap) {
-            var map = this._categoriesMap = new HashMap();
-            var srcCategories = this.options.srcCategories;
-            for (var idx = 0; idx < srcCategories.length; idx++) {
+            const map = this._categoriesMap = new HashMap();
+            const srcCategories = this.options.srcCategories;
+            for (let idx = 0; idx < srcCategories.length; idx++) {
                 map.set(srcCategories[idx], idx);
             }
         }
-    };
+    }
 
-    CategoryAxis.prototype.totalCount = function totalCount () {
+    totalCount() {
         return Math.max(this.options.srcCategories.length, this._seriesMax || 0);
-    };
-
-    return CategoryAxis;
-}(Axis));
+    }
+}
 
 setDefaultOptions(CategoryAxis, {
     type: "category",