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

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

@@ -13,11 +13,11 @@ import { dateComparer, toDate, addTicks, addDuration, dateDiff, absoluteDateDiff
 
 import { DateLabelFormats } from './constants';
 
-var AUTO = "auto";
-var BASE_UNITS = [
+const AUTO = "auto";
+const BASE_UNITS = [
     MILLISECONDS, SECONDS, MINUTES, HOURS, DAYS, WEEKS, MONTHS, YEARS
 ];
-var FIT = "fit";
+const FIT = "fit";
 
 
 function categoryRange(categories, clearCache) {
@@ -25,7 +25,7 @@ function categoryRange(categories, clearCache) {
         categories._range = undefined;
     }
 
-    var range = categories._range;
+    let range = categories._range;
     if (!range) {
         range = categories._range = sparseArrayLimits(categories);
         range.min = toDate(range.min);
@@ -35,202 +35,201 @@ function categoryRange(categories, clearCache) {
     return range;
 }
 
-var EmptyDateRange = function EmptyDateRange(options) {
-    this.options = options;
-};
+class EmptyDateRange {
+    constructor(options) {
+        this.options = options;
+    }
+
+    displayIndices() {
+        return {
+            min: 0,
+            max: 1
+        };
+    }
 
-EmptyDateRange.prototype.displayIndices = function displayIndices () {
-    return {
-        min: 0,
-        max: 1
-    };
-};
+    displayRange() {
+        return {};
+    }
 
-EmptyDateRange.prototype.displayRange = function displayRange () {
-    return {};
-};
+    total() {
+        return {};
+    }
 
-EmptyDateRange.prototype.total = function total () {
-    return {};
-};
+    valueRange() {
+        return {};
+    }
 
-EmptyDateRange.prototype.valueRange = function valueRange () {
-    return {};
-};
+    valueIndex() {
+        return -1;
+    }
 
-EmptyDateRange.prototype.valueIndex = function valueIndex () {
-    return -1;
-};
+    values() {
+        return [];
+    }
 
-EmptyDateRange.prototype.values = function values () {
-    return [];
-};
+    totalIndex() {
+        return -1;
+    }
 
-EmptyDateRange.prototype.totalIndex = function totalIndex () {
-    return -1;
-};
+    valuesCount() {
+        return 0;
+    }
 
-EmptyDateRange.prototype.valuesCount = function valuesCount () {
-    return 0;
-};
+    totalCount() {
+        return 0;
+    }
 
-EmptyDateRange.prototype.totalCount = function totalCount () {
-    return 0;
-};
+    dateAt() {
+        return null;
+    }
+}
 
-EmptyDateRange.prototype.dateAt = function dateAt () {
-    return null;
-};
+class DateRange {
+    constructor(start, end, options) {
+        this.options = options;
+        options.baseUnitStep = options.baseUnitStep || 1;
 
-var DateRange = function DateRange(start, end, options) {
-    this.options = options;
-    options.baseUnitStep = options.baseUnitStep || 1;
+        const { roundToBaseUnit, justified } = options;
 
-    var roundToBaseUnit = options.roundToBaseUnit;
-    var justified = options.justified;
+        this.start = addDuration(start, 0, options.baseUnit, options.weekStartDay);
+        const lowerEnd = this.roundToTotalStep(end);
+        const expandEnd = !justified && dateEquals(end, lowerEnd) && !options.justifyEnd;
 
-    this.start = addDuration(start, 0, options.baseUnit, options.weekStartDay);
-    var lowerEnd = this.roundToTotalStep(end);
-    var expandEnd = !justified && dateEquals(end, lowerEnd) && !options.justifyEnd;
+        this.end = this.roundToTotalStep(end, !justified, expandEnd ? 1 : 0);
 
-    this.end = this.roundToTotalStep(end, !justified, expandEnd ? 1 : 0);
+        const min = options.min || start;
+        this.valueStart = this.roundToTotalStep(min);
+        this.displayStart = roundToBaseUnit ? this.valueStart : min;
 
-    var min = options.min || start;
-    this.valueStart = this.roundToTotalStep(min);
-    this.displayStart = roundToBaseUnit ? this.valueStart : min;
+        const max = options.max;
+        if (!max) {
+            this.valueEnd = lowerEnd;
+            this.displayEnd = roundToBaseUnit || expandEnd ? this.end : end;
+        } else {
+            const next = !justified && dateEquals(max, this.roundToTotalStep(max)) ? -1 : 0;
+            this.valueEnd = this.roundToTotalStep(max, false, next);
+            this.displayEnd = roundToBaseUnit ? this.roundToTotalStep(max, !justified) : options.max;
+        }
 
-    var max = options.max;
-    if (!max) {
-        this.valueEnd = lowerEnd;
-        this.displayEnd = roundToBaseUnit || expandEnd ? this.end : end;
-    } else {
-        var next = !justified && dateEquals(max, this.roundToTotalStep(max)) ? -1 : 0;
-        this.valueEnd = this.roundToTotalStep(max, false, next);
-        this.displayEnd = roundToBaseUnit ? this.roundToTotalStep(max, !justified) : options.max;
+        if (this.valueEnd < this.valueStart) {
+            this.valueEnd = this.valueStart;
+        }
+        if (this.displayEnd <= this.displayStart) {
+            this.displayEnd = this.roundToTotalStep(this.displayStart, false, 1);
+        }
     }
 
-    if (this.valueEnd < this.valueStart) {
-        this.valueEnd = this.valueStart;
-    }
-    if (this.displayEnd <= this.displayStart) {
-        this.displayEnd = this.roundToTotalStep(this.displayStart, false, 1);
+    displayRange() {
+        return {
+            min: this.displayStart,
+            max: this.displayEnd
+        };
     }
-};
 
-DateRange.prototype.displayRange = function displayRange () {
-    return {
-        min: this.displayStart,
-        max: this.displayEnd
-    };
-};
+    displayIndices() {
+        if (!this._indices) {
+            const options = this.options;
 
-DateRange.prototype.displayIndices = function displayIndices () {
-    if (!this._indices) {
-        var options = this.options;
+            const { baseUnit, baseUnitStep } = options;
 
-        var baseUnit = options.baseUnit;
-            var baseUnitStep = options.baseUnitStep;
+            const minIdx = dateIndex(this.displayStart, this.valueStart, baseUnit, baseUnitStep);
+            const maxIdx = dateIndex(this.displayEnd, this.valueStart, baseUnit, baseUnitStep);
 
-        var minIdx = dateIndex(this.displayStart, this.valueStart, baseUnit, baseUnitStep);
-        var maxIdx = dateIndex(this.displayEnd, this.valueStart, baseUnit, baseUnitStep);
+            this._indices = { min: minIdx, max: maxIdx };
+        }
 
-        this._indices = { min: minIdx, max: maxIdx };
+        return this._indices;
     }
 
-    return this._indices;
-};
-
-DateRange.prototype.total = function total () {
-    return {
-        min: this.start,
-        max: this.end
-    };
-};
+    total() {
+        return {
+            min: this.start,
+            max: this.end
+        };
+    }
 
-DateRange.prototype.totalCount = function totalCount () {
-    var last = this.totalIndex(this.end);
+    totalCount() {
+        const last = this.totalIndex(this.end);
 
-    return last + (this.options.justified ? 1 : 0);
-};
+        return last + (this.options.justified ? 1 : 0);
+    }
 
-DateRange.prototype.valueRange = function valueRange () {
-    return {
-        min: this.valueStart,
-        max: this.valueEnd
-    };
-};
+    valueRange() {
+        return {
+            min: this.valueStart,
+            max: this.valueEnd
+        };
+    }
 
-DateRange.prototype.valueIndex = function valueIndex (value) {
-    var options = this.options;
-    return Math.floor(dateIndex(value, this.valueStart, options.baseUnit, options.baseUnitStep));
-};
+    valueIndex(value) {
+        const options = this.options;
+        return Math.floor(dateIndex(value, this.valueStart, options.baseUnit, options.baseUnitStep));
+    }
 
-DateRange.prototype.totalIndex = function totalIndex (value) {
-    var options = this.options;
-    return Math.floor(dateIndex(value, this.start, options.baseUnit, options.baseUnitStep));
-};
+    totalIndex(value) {
+        const options = this.options;
+        return Math.floor(dateIndex(value, this.start, options.baseUnit, options.baseUnitStep));
+    }
 
-DateRange.prototype.dateIndex = function dateIndex$1 (value) {
-    var options = this.options;
-    return dateIndex(value, this.valueStart, options.baseUnit, options.baseUnitStep);
-};
+    dateIndex(value) {
+        const options = this.options;
+        return dateIndex(value, this.valueStart, options.baseUnit, options.baseUnitStep);
+    }
 
-DateRange.prototype.valuesCount = function valuesCount () {
-    var maxIdx = this.valueIndex(this.valueEnd);
+    valuesCount() {
+        const maxIdx = this.valueIndex(this.valueEnd);
 
-    return maxIdx + 1;
-};
+        return maxIdx + 1;
+    }
 
-DateRange.prototype.values = function values () {
-    var values = this._values;
-    if (!values) {
-        var options = this.options;
-        var range = this.valueRange();
-        this._values = values = [];
+    values() {
+        let values = this._values;
+        if (!values) {
+            const options = this.options;
+            const range = this.valueRange();
+            this._values = values = [];
 
-        for (var date = range.min; date <= range.max;) {
-            values.push(date);
-            date = addDuration(date, options.baseUnitStep, options.baseUnit, options.weekStartDay);
+            for (let date = range.min; date <= range.max;) {
+                values.push(date);
+                date = addDuration(date, options.baseUnitStep, options.baseUnit, options.weekStartDay);
+            }
         }
+
+        return values;
     }
 
-    return values;
-};
+    dateAt(index, total) {
+        const options = this.options;
 
-DateRange.prototype.dateAt = function dateAt (index, total) {
-    var options = this.options;
+        return addDuration(total ? this.start : this.valueStart, options.baseUnitStep * index, options.baseUnit, options.weekStartDay);
+    }
 
-    return addDuration(total ? this.start : this.valueStart, options.baseUnitStep * index, options.baseUnit, options.weekStartDay);
-};
+    roundToTotalStep(value, upper, next) {
+        const { baseUnit, baseUnitStep, weekStartDay } = this.options;
+        const start = this.start;
 
-DateRange.prototype.roundToTotalStep = function roundToTotalStep (value, upper, next) {
-    var ref = this.options;
-        var baseUnit = ref.baseUnit;
-        var baseUnitStep = ref.baseUnitStep;
-        var weekStartDay = ref.weekStartDay;
-    var start = this.start;
+        const step = dateIndex(value, start, baseUnit, baseUnitStep);
+        let roundedStep = upper ? Math.ceil(step) : Math.floor(step);
 
-    var step = dateIndex(value, start, baseUnit, baseUnitStep);
-    var roundedStep = upper ? Math.ceil(step) : Math.floor(step);
+        if (next) {
+            roundedStep += next;
+        }
 
-    if (next) {
-        roundedStep += next;
+        return addDuration(start, roundedStep * baseUnitStep, baseUnit, weekStartDay);
     }
 
-    return addDuration(start, roundedStep * baseUnitStep, baseUnit, weekStartDay);
-};
+}
 
 function autoBaseUnit(options, startUnit, startStep) {
-    var categoryLimits = categoryRange(options.categories);
-    var span = (options.max || categoryLimits.max) - (options.min || categoryLimits.min);
-    var autoBaseUnitSteps = options.autoBaseUnitSteps;
-    var maxDateGroups = options.maxDateGroups;
-    var autoUnit = options.baseUnit === FIT;
-    var autoUnitIx = startUnit ? BASE_UNITS.indexOf(startUnit) : 0;
-    var baseUnit = autoUnit ? BASE_UNITS[autoUnitIx++] : options.baseUnit;
-    var units = span / TIME_PER_UNIT[baseUnit];
-    var totalUnits = units;
-    var unitSteps, step, nextStep;
+    const categoryLimits = categoryRange(options.categories);
+    const span = (options.max || categoryLimits.max) - (options.min || categoryLimits.min);
+    const { autoBaseUnitSteps, maxDateGroups } = options;
+    const autoUnit = options.baseUnit === FIT;
+    let autoUnitIx = startUnit ? BASE_UNITS.indexOf(startUnit) : 0;
+    let baseUnit = autoUnit ? BASE_UNITS[autoUnitIx++] : options.baseUnit;
+    let units = span / TIME_PER_UNIT[baseUnit];
+    let totalUnits = units;
+    let unitSteps, step, nextStep;
 
     while (!step || units >= maxDateGroups) {
         unitSteps = unitSteps || autoBaseUnitSteps[baseUnit].slice(0);
@@ -262,16 +261,16 @@ function autoBaseUnit(options, startUnit, startStep) {
 }
 
 function defaultBaseUnit(options) {
-    var categories = options.categories;
-    var count = defined(categories) ? categories.length : 0;
-    var minDiff = MAX_VALUE;
-    var lastCategory, unit;
+    const categories = options.categories;
+    const count = defined(categories) ? categories.length : 0;
+    let minDiff = MAX_VALUE;
+    let lastCategory, unit;
 
-    for (var categoryIx = 0; categoryIx < count; categoryIx++) {
-        var category = categories[categoryIx];
+    for (let categoryIx = 0; categoryIx < count; categoryIx++) {
+        const category = categories[categoryIx];
 
         if (category && lastCategory) {
-            var diff = Math.abs(absoluteDateDiff(category, lastCategory));
+            let diff = Math.abs(absoluteDateDiff(category, lastCategory));
 
             if (diff !== 0) {
                 minDiff = Math.min(minDiff, diff);
@@ -301,8 +300,8 @@ function defaultBaseUnit(options) {
 }
 
 function initUnit(options) {
-    var baseUnit = (options.baseUnit || "").toLowerCase();
-    var useDefault = baseUnit !== FIT && !inArray(baseUnit, BASE_UNITS);
+    const baseUnit = (options.baseUnit || "").toLowerCase();
+    const useDefault = baseUnit !== FIT && !inArray(baseUnit, BASE_UNITS);
 
     if (useDefault) {
         defaultBaseUnit(options);
@@ -315,39 +314,32 @@ function initUnit(options) {
     return options;
 }
 
-var DateCategoryAxis = (function (CategoryAxis) {
-    function DateCategoryAxis () {
-        CategoryAxis.apply(this, arguments);
-    }
-
-    if ( CategoryAxis ) DateCategoryAxis.__proto__ = CategoryAxis;
-    DateCategoryAxis.prototype = Object.create( CategoryAxis && CategoryAxis.prototype );
-    DateCategoryAxis.prototype.constructor = DateCategoryAxis;
+class DateCategoryAxis extends CategoryAxis {
 
-    DateCategoryAxis.prototype.clone = function clone () {
-        var copy = new DateCategoryAxis(Object.assign({}, this.options), this.chartService);
+    clone() {
+        const copy = new DateCategoryAxis(Object.assign({}, this.options), this.chartService);
         copy.createLabels();
 
         return copy;
-    };
+    }
 
-    DateCategoryAxis.prototype.categoriesHash = function categoriesHash () {
-        var start = this.dataRange.total().min;
+    categoriesHash() {
+        const start = this.dataRange.total().min;
         return this.options.baseUnit + this.options.baseUnitStep + start;
-    };
+    }
 
-    DateCategoryAxis.prototype.initUserOptions = function initUserOptions (options) {
+    initUserOptions(options) {
         return options;
-    };
+    }
 
-    DateCategoryAxis.prototype.initFields = function initFields () {
-        CategoryAxis.prototype.initFields.call(this);
+    initFields() {
+        super.initFields();
 
-        var chartService = this.chartService;
-        var intlService = chartService.intl;
-        var options = this.options;
+        const chartService = this.chartService;
+        const intlService = chartService.intl;
+        let options = this.options;
 
-        var categories = options.categories || [];
+        let categories = options.categories || [];
         if (!categories._parsed) {
             categories = parseDates(intlService, categories);
             categories._parsed = true;
@@ -373,11 +365,11 @@ var DateCategoryAxis = (function (CategoryAxis) {
         options.srcCategories = categories;
 
         if (categories.length > 0) {
-            var range = categoryRange(categories, true);
-            var maxDivisions = options.maxDivisions;
-            var safeOptions = initUnit(options);
+            const range = categoryRange(categories, true);
+            const maxDivisions = options.maxDivisions;
+            const safeOptions = initUnit(options);
 
-            var forecast = options._forecast;
+            const forecast = options._forecast;
             if (forecast) {
                 if (forecast.before > 0) {
                     range.min = addDuration(range.min, -forecast.before, safeOptions.baseUnit, safeOptions.weekStartDay);
@@ -391,9 +383,9 @@ var DateCategoryAxis = (function (CategoryAxis) {
             this.dataRange = new DateRange(range.min, range.max, safeOptions);
 
             if (maxDivisions) {
-                var dataRange = this.dataRange.displayRange();
+                const dataRange = this.dataRange.displayRange();
 
-                var divisionOptions = Object.assign({}, options, {
+                const divisionOptions = Object.assign({}, options, {
                     justified: true,
                     roundToBaseUnit: false,
                     baseUnit: 'fit',
@@ -402,7 +394,7 @@ var DateCategoryAxis = (function (CategoryAxis) {
                     maxDateGroups: maxDivisions
                 });
 
-                var dataRangeOptions = this.dataRange.options;
+                const dataRangeOptions = this.dataRange.options;
 
                 autoBaseUnit(divisionOptions, dataRangeOptions.baseUnit, dataRangeOptions.baseUnitStep);
 
@@ -417,67 +409,63 @@ var DateCategoryAxis = (function (CategoryAxis) {
         }
 
         this.rangeLabels = [];
-    };
+    }
 
-    DateCategoryAxis.prototype.tickIndices = function tickIndices (stepSize) {
-        var ref = this;
-        var dataRange = ref.dataRange;
-        var divisionRange = ref.divisionRange;
-        var valuesCount = divisionRange.valuesCount();
+    tickIndices(stepSize) {
+        const { dataRange, divisionRange } = this;
+        const valuesCount = divisionRange.valuesCount();
 
         if (!this.options.maxDivisions || !valuesCount) {
-            return CategoryAxis.prototype.tickIndices.call(this, stepSize);
+            return super.tickIndices(stepSize);
         }
 
-        var indices = [];
-        var values = divisionRange.values();
-        var offset = 0;
+        const indices = [];
+        let values = divisionRange.values();
+        let offset = 0;
 
         if (!this.options.justified) {
             values = values.concat(divisionRange.dateAt(valuesCount));
             offset = 0.5;//align ticks to the center of not justified categories
         }
 
-        for (var idx = 0; idx < values.length; idx++) {
+        for (let idx = 0; idx < values.length; idx++) {
             indices.push(dataRange.dateIndex(values[idx]) + offset);
             if (stepSize !== 1 && idx >= 1) {
-                var last = indices.length - 1;
+                const last = indices.length - 1;
                 indices.splice(idx, 0, indices[last - 1] + (indices[last] - indices[last - 1]) * stepSize);
             }
         }
 
         return indices;
-    };
+    }
 
-    DateCategoryAxis.prototype.shouldRenderNote = function shouldRenderNote (value) {
-        var range = this.range();
-        var categories = this.options.categories || [];
+    shouldRenderNote(value) {
+        const range = this.range();
+        const categories = this.options.categories || [];
 
         return dateComparer(value, range.min) >= 0 && dateComparer(value, range.max) <= 0 && categories.length;
-    };
+    }
 
-    DateCategoryAxis.prototype.parseNoteValue = function parseNoteValue (value) {
+    parseNoteValue(value) {
         return parseDate(this.chartService.intl, value);
-    };
+    }
 
-    DateCategoryAxis.prototype.noteSlot = function noteSlot (value) {
+    noteSlot(value) {
         return this.getSlot(value);
-    };
-
-    DateCategoryAxis.prototype.translateRange = function translateRange (delta) {
-        var options = this.options;
-        var baseUnit = options.baseUnit;
-        var weekStartDay = options.weekStartDay;
-        var vertical = options.vertical;
-        var lineBox = this.lineBox();
-        var size = vertical ? lineBox.height() : lineBox.width();
-        var range = this.range();
-        var scale = size / (range.max - range.min);
-        var offset = round(delta / scale, DEFAULT_PRECISION);
+    }
+
+    translateRange(delta) {
+        const options = this.options;
+        const { baseUnit, weekStartDay, vertical } = options;
+        const lineBox = this.lineBox();
+        const size = vertical ? lineBox.height() : lineBox.width();
+        let range = this.range();
+        const scale = size / (range.max - range.min);
+        const offset = round(delta / scale, DEFAULT_PRECISION);
 
         if (range.min && range.max) {
-            var from = addTicks(options.min || range.min, offset);
-            var to = addTicks(options.max || range.max, offset);
+            const from = addTicks(options.min || range.min, offset);
+            const to = addTicks(options.max || range.max, offset);
 
             range = {
                 min: addDuration(from, 0, baseUnit, weekStartDay),
@@ -486,33 +474,31 @@ var DateCategoryAxis = (function (CategoryAxis) {
         }
 
         return range;
-    };
+    }
 
-    DateCategoryAxis.prototype.labelsRange = function labelsRange () {
+    labelsRange() {
         return {
             min: this.options.labels.skip,
             max: this.divisionRange.valuesCount()
         };
-    };
+    }
 
-    DateCategoryAxis.prototype.pan = function pan (delta) {
+    pan(delta) {
         if (this.isEmpty()) {
             return null;
         }
 
-        var options = this.options;
-        var lineBox = this.lineBox();
-        var size = options.vertical ? lineBox.height() : lineBox.width();
-        var ref = this.dataRange.displayRange();
-        var min = ref.min;
-        var max = ref.max;
-        var totalLimits = this.dataRange.total();
-        var scale = size / (max - min);
-        var offset = round(delta / scale, DEFAULT_PRECISION) * (options.reverse ? -1 : 1);
-        var from = addTicks(min, offset);
-        var to = addTicks(max, offset);
+        const options = this.options;
+        const lineBox = this.lineBox();
+        const size = options.vertical ? lineBox.height() : lineBox.width();
+        const { min, max } = this.dataRange.displayRange();
+        const totalLimits = this.dataRange.total();
+        const scale = size / (max - min);
+        const offset = round(delta / scale, DEFAULT_PRECISION) * (options.reverse ? -1 : 1);
+        const from = addTicks(min, offset);
+        const to = addTicks(max, offset);
 
-        var panRange = this.limitRange(toTime(from), toTime(to), toTime(totalLimits.min), toTime(totalLimits.max), offset);
+        const panRange = this.limitRange(toTime(from), toTime(to), toTime(totalLimits.min), toTime(totalLimits.max), offset);
 
         if (panRange) {
             panRange.min = toDate(panRange.min);
@@ -524,21 +510,21 @@ var DateCategoryAxis = (function (CategoryAxis) {
 
             return panRange;
         }
-    };
+    }
 
-    DateCategoryAxis.prototype.pointsRange = function pointsRange (start, end) {
+    pointsRange(start, end) {
         if (this.isEmpty()) {
             return null;
         }
 
-        var pointsRange = CategoryAxis.prototype.pointsRange.call(this, start, end);
-        var datesRange = this.dataRange.displayRange();
-        var indicesRange = this.dataRange.displayIndices();
-        var scale = dateDiff(datesRange.max, datesRange.min) / (indicesRange.max - indicesRange.min);
-        var options = this.options;
+        const pointsRange = super.pointsRange(start, end);
+        const datesRange = this.dataRange.displayRange();
+        const indicesRange = this.dataRange.displayIndices();
+        const scale = dateDiff(datesRange.max, datesRange.min) / (indicesRange.max - indicesRange.min);
+        const options = this.options;
 
-        var min = addTicks(datesRange.min, pointsRange.min * scale);
-        var max = addTicks(datesRange.min, pointsRange.max * scale);
+        const min = addTicks(datesRange.min, pointsRange.min * scale);
+        const max = addTicks(datesRange.min, pointsRange.max * scale);
 
         return {
             min: min,
@@ -546,40 +532,36 @@ var DateCategoryAxis = (function (CategoryAxis) {
             baseUnit: options.userSetBaseUnit || options.baseUnit,
             baseUnitStep: options.userSetBaseUnitStep || options.baseUnitStep
         };
-    };
+    }
 
-    DateCategoryAxis.prototype.scaleRange = function scaleRange (scale, cursor) {
+    scaleRange(scale, cursor) {
         if (this.isEmpty()) {
             return {};
         }
 
-        var options = this.options;
-        var fit = options.userSetBaseUnit === FIT;
-        var totalLimits = this.dataRange.total();
-        var ref = this.dataRange.displayRange();
-        var rangeMin = ref.min;
-        var rangeMax = ref.max;
+        const options = this.options;
+        const fit = options.userSetBaseUnit === FIT;
+        const totalLimits = this.dataRange.total();
+        const { min: rangeMin, max: rangeMax } = this.dataRange.displayRange();
 
-        var position = Math.abs(this.pointOffset(cursor));
-        var range = rangeMax - rangeMin;
-        var delta = this.scaleToDelta(scale, range);
-        var minDelta = Math.round(position * delta);
-        var maxDelta = Math.round((1 - position) * delta);
+        const position = Math.abs(this.pointOffset(cursor));
+        const range = rangeMax - rangeMin;
+        const delta = this.scaleToDelta(scale, range);
+        const minDelta = Math.round(position * delta);
+        const maxDelta = Math.round((1 - position) * delta);
 
-        var ref$1 = this.dataRange.options;
-        var baseUnit = ref$1.baseUnit;
-        var min = new Date(rangeMin.getTime() + minDelta);
-        var max = new Date(rangeMax.getTime() - maxDelta);
+        let { baseUnit } = this.dataRange.options;
+        let min = new Date(rangeMin.getTime() + minDelta);
+        let max = new Date(rangeMax.getTime() - maxDelta);
 
         if (fit) {
-            var autoBaseUnitSteps = options.autoBaseUnitSteps;
-            var maxDateGroups = options.maxDateGroups;
+            const { autoBaseUnitSteps, maxDateGroups } = options;
 
-            var maxDiff = last(autoBaseUnitSteps[baseUnit]) * maxDateGroups * TIME_PER_UNIT[baseUnit];
-            var rangeDiff = dateDiff(rangeMax, rangeMin);
-            var diff = dateDiff(max, min);
-            var baseUnitIndex = BASE_UNITS.indexOf(baseUnit);
-            var autoBaseUnitStep, ticks;
+            const maxDiff = last(autoBaseUnitSteps[baseUnit]) * maxDateGroups * TIME_PER_UNIT[baseUnit];
+            const rangeDiff = dateDiff(rangeMax, rangeMin);
+            const diff = dateDiff(max, min);
+            let baseUnitIndex = BASE_UNITS.indexOf(baseUnit);
+            let autoBaseUnitStep, ticks;
 
             if (diff < TIME_PER_UNIT[baseUnit] && baseUnit !== MILLISECONDS) {
                 baseUnit = BASE_UNITS[baseUnitIndex - 1];
@@ -589,7 +571,7 @@ var DateCategoryAxis = (function (CategoryAxis) {
                 max = addTicks(rangeMax, -ticks);
 
             } else if (diff > maxDiff && baseUnit !== YEARS) {
-                var stepIndex = 0;
+                let stepIndex = 0;
 
                 do {
                     baseUnitIndex++;
@@ -620,11 +602,11 @@ var DateCategoryAxis = (function (CategoryAxis) {
                 baseUnitStep: options.userSetBaseUnitStep || options.baseUnitStep
             };
         }
-    };
+    }
 
-    DateCategoryAxis.prototype.zoomRange = function zoomRange (scale, cursor) {
-        var totalLimits = this.dataRange.total();
-        var range = this.scaleRange(scale, cursor);
+    zoomRange(scale, cursor) {
+        const totalLimits = this.dataRange.total();
+        const range = this.scaleRange(scale, cursor);
 
         if (range) {
             if (range.min < totalLimits.min) {
@@ -636,66 +618,62 @@ var DateCategoryAxis = (function (CategoryAxis) {
         }
 
         return range;
-    };
+    }
 
-    DateCategoryAxis.prototype.range = function range () {
+    range() {
         return this.dataRange.displayRange();
-    };
+    }
 
-    DateCategoryAxis.prototype.createLabels = function createLabels () {
-        CategoryAxis.prototype.createLabels.call(this);
+    createLabels() {
+        super.createLabels();
         this.createRangeLabels();
-    };
+    }
 
-    DateCategoryAxis.prototype.clearLabels = function clearLabels () {
-        CategoryAxis.prototype.clearLabels.call(this);
+    clearLabels() {
+        super.clearLabels();
         this.rangeLabels = [];
-    };
+    }
 
-    DateCategoryAxis.prototype.arrangeLabels = function arrangeLabels () {
+    arrangeLabels() {
         this.arrangeRangeLabels();
-        CategoryAxis.prototype.arrangeLabels.call(this);
-    };
+        super.arrangeLabels();
+    }
 
-    DateCategoryAxis.prototype.arrangeRangeLabels = function arrangeRangeLabels () {
-        var ref = this;
-        var options = ref.options;
-        var rangeLabels = ref.rangeLabels;
+    arrangeRangeLabels() {
+        const { options, rangeLabels } = this;
         if (rangeLabels.length === 0) {
             return;
         }
 
-        var lineBox = this.lineBox();
-        var vertical = options.vertical;
-        var mirror = options.rangeLabels.mirror || options.labels.mirror;
+        const lineBox = this.lineBox();
+        const vertical = options.vertical;
+        const mirror = options.rangeLabels.mirror || options.labels.mirror;
 
-        var firstLabel = rangeLabels[0];
+        const firstLabel = rangeLabels[0];
         if (firstLabel) {
-            var position = vertical ? lineBox.y1 - (firstLabel.box.height() / 2) : lineBox.x1;
+            const position = vertical ? lineBox.y1 - (firstLabel.box.height() / 2) : lineBox.x1;
             this.positionLabel(firstLabel, mirror, position);
         }
 
-        var lastLabel = rangeLabels[1];
+        const lastLabel = rangeLabels[1];
         if (lastLabel) {
-            var position$1 = vertical ? lineBox.y2 - (lastLabel.box.height() / 2) : lineBox.x2;
-            this.positionLabel(lastLabel, mirror, position$1);
+            const position = vertical ? lineBox.y2 - (lastLabel.box.height() / 2) : lineBox.x2;
+            this.positionLabel(lastLabel, mirror, position);
         }
-    };
+    }
 
-    DateCategoryAxis.prototype.autoRotateLabels = function autoRotateLabels () {
-        CategoryAxis.prototype.autoRotateLabels.call(this);
+    autoRotateLabels() {
+        super.autoRotateLabels();
         this.autoRotateRangeLabels();
-    };
+    }
 
-    DateCategoryAxis.prototype.hideOutOfRangeLabels = function hideOutOfRangeLabels () {
-        CategoryAxis.prototype.hideOutOfRangeLabels.call(this);
+    hideOutOfRangeLabels() {
+        super.hideOutOfRangeLabels();
         this.hideOverlappingLabels();
-    };
+    }
 
-    DateCategoryAxis.prototype.hideOverlappingLabels = function hideOverlappingLabels () {
-        var ref = this;
-        var rangeLabels = ref.rangeLabels;
-        var labels = ref.labels;
+    hideOverlappingLabels() {
+        const { rangeLabels, labels } = this;
         if (rangeLabels.length === 0) {
             return;
         }
@@ -709,66 +687,60 @@ var DateCategoryAxis = (function (CategoryAxis) {
             return false;
         }
 
-        var firstRangeLabel = rangeLabels[0];
+        const firstRangeLabel = rangeLabels[0];
         if (firstRangeLabel && firstRangeLabel.options.visible) {
-            for (var i = 0; i < labels.length; i++) {
-                var overlaps = clip(firstRangeLabel, labels[i]);
+            for (let i = 0; i < labels.length; i++) {
+                const overlaps = clip(firstRangeLabel, labels[i]);
                 if (!overlaps) {
                     break;
                 }
             }
         }
 
-        var lastRangeLabel = rangeLabels[1];
+        const lastRangeLabel = rangeLabels[1];
         if (lastRangeLabel && lastRangeLabel.options.visible) {
-            for (var i$1 = labels.length - 1; i$1 > 0; --i$1) {
-                var overlaps$1 = clip(lastRangeLabel, labels[i$1]);
-                if (!overlaps$1) {
+            for (let i = labels.length - 1; i > 0; --i) {
+                const overlaps = clip(lastRangeLabel, labels[i]);
+                if (!overlaps) {
                     break;
                 }
             }
         }
-    };
+    }
 
-    DateCategoryAxis.prototype.contentBox = function contentBox () {
-        var box = CategoryAxis.prototype.contentBox.call(this);
-        var rangeLabels = this.rangeLabels;
+    contentBox() {
+        const box = super.contentBox();
+        const rangeLabels = this.rangeLabels;
 
-        for (var i = 0; i < rangeLabels.length; i++) {
-            var label = rangeLabels[i];
+        for (let i = 0; i < rangeLabels.length; i++) {
+            const label = rangeLabels[i];
             if (label.options.visible) {
                 box.wrap(label.box);
             }
         }
 
         return box;
-    };
-
-    DateCategoryAxis.prototype.createAxisLabel = function createAxisLabel (index, labelOptions, labelContext) {
-        if ( labelContext === void 0 ) labelContext = {};
+    }
 
-        var options = this.options;
-        var dataItem = options.dataItems && !options.maxDivisions ? options.dataItems[index] : null;
-        var date = this.divisionRange.dateAt(index);
-        var unitFormat = labelOptions.dateFormats[this.divisionRange.options.baseUnit];
+    createAxisLabel(index, labelOptions, labelContext = {}) {
+        const options = this.options;
+        const dataItem = options.dataItems && !options.maxDivisions ? options.dataItems[index] : null;
+        const date = this.divisionRange.dateAt(index);
+        const unitFormat = labelOptions.dateFormats[this.divisionRange.options.baseUnit];
 
         labelOptions.format = labelOptions.format || unitFormat;
         labelContext.dataItem = dataItem;
 
-        var text = this.axisLabelText(date, labelOptions, labelContext);
+        const text = this.axisLabelText(date, labelOptions, labelContext);
         if (text) {
             return new AxisLabel(date, text, index, dataItem, labelOptions);
         }
-    };
-
-    DateCategoryAxis.prototype.createRangeLabels = function createRangeLabels () {
-        var this$1 = this;
+    }
 
-        var ref = this.divisionRange;
-        var displayStart = ref.displayStart;
-        var displayEnd = ref.displayEnd;
-        var options = this.options;
-        var labelOptions = Object.assign({}, options.labels, options.rangeLabels, {
+    createRangeLabels() {
+        const { displayStart, displayEnd } = this.divisionRange;
+        const options = this.options;
+        const labelOptions = Object.assign({}, options.labels, options.rangeLabels, {
             align: CENTER,
             zIndex: options.zIndex
         });
@@ -785,54 +757,52 @@ var DateCategoryAxis = (function (CategoryAxis) {
             options.autoRotateRangeLabels = true;
         }
 
-        var unitFormat = labelOptions.dateFormats[this.divisionRange.options.baseUnit];
+        const unitFormat = labelOptions.dateFormats[this.divisionRange.options.baseUnit];
         labelOptions.format = labelOptions.format || unitFormat;
 
-        var createLabel = function (index, date, text) {
+        const createLabel = (index, date, text) => {
             if (text) {
-                var label = new AxisLabel(date, text, index, null, labelOptions);
-                this$1.append(label);
-                this$1.rangeLabels.push(label);
+                const label = new AxisLabel(date, text, index, null, labelOptions);
+                this.append(label);
+                this.rangeLabels.push(label);
             }
         };
 
-        var startText = this.axisLabelText(displayStart, labelOptions, { index: 0, count: 2 });
+        const startText = this.axisLabelText(displayStart, labelOptions, { index: 0, count: 2 });
         createLabel(0, displayStart, startText);
 
-        var endText = this.axisLabelText(displayEnd, labelOptions, { index: 1, count: 2 });
+        const endText = this.axisLabelText(displayEnd, labelOptions, { index: 1, count: 2 });
         createLabel(1, displayEnd, endText);
-    };
-
-    DateCategoryAxis.prototype.autoRotateRangeLabels = function autoRotateRangeLabels () {
-        var this$1 = this;
+    }
 
-        var labels = this.rangeLabels;
+    autoRotateRangeLabels() {
+        const labels = this.rangeLabels;
         if (!this.options.autoRotateRangeLabels || this.options.vertical || labels.length !== 2) {
             return;
         }
 
-        var rotateLabel = function (label, tickPositions, index) {
-            var width = Math.abs(tickPositions[index + 1] - tickPositions[index]) * 2;
-            var angle = this$1.autoRotateLabelAngle(label.box, width);
+        const rotateLabel = (label, tickPositions, index) => {
+            const width = Math.abs(tickPositions[index + 1] - tickPositions[index]) * 2;
+            const angle = this.autoRotateLabelAngle(label.box, width);
             if (angle !== 0) {
                 label.options.rotation = angle;
                 label.reflow(new Box());
             }
         };
 
-        var tickPositions = this.getMajorTickPositions();
+        const tickPositions = this.getMajorTickPositions();
         rotateLabel(labels[0], tickPositions, 0);
         rotateLabel(labels[1], tickPositions, tickPositions.length - 2);
-    };
+    }
 
-    DateCategoryAxis.prototype.categoryIndex = function categoryIndex (value) {
+    categoryIndex(value) {
         return this.dataRange.valueIndex(value);
-    };
+    }
 
-    DateCategoryAxis.prototype.slot = function slot (from, to, limit) {
-        var dateRange = this.dataRange;
-        var start = from;
-        var end = to;
+    slot(from, to, limit) {
+        const dateRange = this.dataRange;
+        let start = from;
+        let end = to;
 
         if (start instanceof Date) {
             start = dateRange.dateIndex(start);
@@ -842,15 +812,15 @@ var DateCategoryAxis = (function (CategoryAxis) {
             end = dateRange.dateIndex(end);
         }
 
-        var slot = this.getSlot(start, end, limit);
+        const slot = this.getSlot(start, end, limit);
         if (slot) {
             return slot.toRect();
         }
-    };
+    }
 
-    DateCategoryAxis.prototype.getSlot = function getSlot (a, b, limit) {
-        var start = a;
-        var end = b;
+    getSlot(a, b, limit) {
+        let start = a;
+        let end = b;
 
         if (typeof start === OBJECT) {
             start = this.categoryIndex(start);
@@ -860,104 +830,102 @@ var DateCategoryAxis = (function (CategoryAxis) {
             end = this.categoryIndex(end);
         }
 
-        return CategoryAxis.prototype.getSlot.call(this, start, end, limit);
-    };
+        return super.getSlot(start, end, limit);
+    }
 
-    DateCategoryAxis.prototype.valueRange = function valueRange () {
-        var options = this.options;
-        var range = categoryRange(options.srcCategories);
+    valueRange() {
+        const options = this.options;
+        const range = categoryRange(options.srcCategories);
 
         return {
             min: toDate(range.min),
             max: toDate(range.max)
         };
-    };
+    }
 
-    DateCategoryAxis.prototype.categoryAt = function categoryAt (index, total) {
+    categoryAt(index, total) {
         return this.dataRange.dateAt(index, total);
-    };
+    }
 
-    DateCategoryAxis.prototype.categoriesCount = function categoriesCount () {
+    categoriesCount() {
         return this.dataRange.valuesCount();
-    };
+    }
 
-    DateCategoryAxis.prototype.rangeIndices = function rangeIndices () {
+    rangeIndices() {
         return this.dataRange.displayIndices();
-    };
+    }
 
-    DateCategoryAxis.prototype.labelsBetweenTicks = function labelsBetweenTicks () {
+    labelsBetweenTicks() {
         return !this.divisionRange.options.justified;
-    };
+    }
 
-    DateCategoryAxis.prototype.prepareUserOptions = function prepareUserOptions () {
+    prepareUserOptions() {
         if (this.isEmpty()) {
             return;
         }
 
         this.options.categories = this.dataRange.values();
-    };
+    }
 
-    DateCategoryAxis.prototype.getCategory = function getCategory (point) {
-        var index = this.pointCategoryIndex(point);
+    getCategory(point) {
+        const index = this.pointCategoryIndex(point);
 
         if (index === null) {
             return null;
         }
 
         return this.dataRange.dateAt(index);
-    };
+    }
 
-    DateCategoryAxis.prototype.totalIndex = function totalIndex (value) {
+    totalIndex(value) {
         return this.dataRange.totalIndex(value);
-    };
+    }
 
-    DateCategoryAxis.prototype.currentRangeIndices = function currentRangeIndices () {
-        var range = this.dataRange.valueRange();
+    currentRangeIndices() {
+        const range = this.dataRange.valueRange();
         return {
             min: this.dataRange.totalIndex(range.min),
             max: this.dataRange.totalIndex(range.max)
         };
-    };
+    }
 
-    DateCategoryAxis.prototype.totalRange = function totalRange () {
+    totalRange() {
         return this.dataRange.total();
-    };
+    }
 
-    DateCategoryAxis.prototype.totalRangeIndices = function totalRangeIndices () {
-        var range = this.dataRange.total();
+    totalRangeIndices() {
+        const range = this.dataRange.total();
         return {
             min: this.dataRange.totalIndex(range.min),
             max: this.dataRange.totalIndex(range.max)
         };
-    };
+    }
 
-    DateCategoryAxis.prototype.totalCount = function totalCount () {
+    totalCount() {
         return this.dataRange.totalCount();
-    };
+    }
 
-    DateCategoryAxis.prototype.isEmpty = function isEmpty () {
+    isEmpty() {
         return !this.options.srcCategories.length;
-    };
+    }
 
-    DateCategoryAxis.prototype.roundedRange = function roundedRange () {
+    roundedRange() {
         if (this.options.roundToBaseUnit !== false || this.isEmpty()) {
             return this.range();
         }
 
-        var options = this.options;
-        var datesRange = categoryRange(options.srcCategories);
+        const options = this.options;
+        const datesRange = categoryRange(options.srcCategories);
 
-        var dateRange = new DateRange(datesRange.min, datesRange.max, Object.assign({}, options, {
+        const dateRange = new DateRange(datesRange.min, datesRange.max, Object.assign({}, options, {
             justified: false,
             roundToBaseUnit: true,
             justifyEnd: false
         }));
 
         return dateRange.displayRange();
-    };
-
-    return DateCategoryAxis;
-}(CategoryAxis));
+    }
+}
 
 setDefaultOptions(DateCategoryAxis, {
     type: DATE,