highcharts 9.1.1 → 9.2.2

package/es-modules/Core/Axis/DateTimeAxis.js

@@ -8,170 +8,200 @@
  *
  * */
 'use strict';
-import Axis from './Axis.js';
 import U from '../Utilities.js';
 var addEvent = U.addEvent, getMagnitude = U.getMagnitude, normalizeTickInterval = U.normalizeTickInterval, timeUnits = U.timeUnits;
+/* *
+ *
+ *  Composition
+ *
+ * */
 /* eslint-disable valid-jsdoc */
-var DateTimeAxisAdditions = /** @class */ (function () {
+var DateTimeAxis;
+(function (DateTimeAxis) {
     /* *
      *
-     *  Constructors
+     *  Declarations
      *
      * */
-    function DateTimeAxisAdditions(axis) {
-        this.axis = axis;
-    }
+    /* *
+     *
+     *  Constants
+     *
+     * */
+    var composedClasses = [];
     /* *
      *
      *  Functions
      *
      * */
     /**
-     * Get a normalized tick interval for dates. Returns a configuration object
-     * with unit range (interval), count and name. Used to prepare data for
-     * `getTimeTicks`. Previously this logic was part of getTimeTicks, but as
-     * `getTimeTicks` now runs of segments in stock charts, the normalizing
-     * logic was extracted in order to prevent it for running over again for
-     * each segment having the same interval. #662, #697.
+     * Extends axis class with date and time support.
      * @private
      */
+    function compose(AxisClass) {
+        if (composedClasses.indexOf(AxisClass) === -1) {
+            composedClasses.push(AxisClass);
+            AxisClass.keepProps.push('dateTime');
+            var axisProto = AxisClass.prototype;
+            axisProto.getTimeTicks = getTimeTicks;
+            addEvent(AxisClass, 'init', onInit);
+        }
+        return AxisClass;
+    }
+    DateTimeAxis.compose = compose;
     /**
-     * Get a normalized tick interval for dates. Returns a configuration object
-     * with unit range (interval), count and name. Used to prepare data for
-     * `getTimeTicks`. Previously this logic was part of getTimeTicks, but as
-     * `getTimeTicks` now runs of segments in stock charts, the normalizing
-     * logic was extracted in order to prevent it for running over again for
-     * each segment having the same interval. #662, #697.
+     * Set the tick positions to a time unit that makes sense, for example
+     * on the first of each month or on every Monday. Return an array with
+     * the time positions. Used in datetime axes as well as for grouping
+     * data on a datetime axis.
+     *
      * @private
+     * @function Highcharts.Axis#getTimeTicks
+     *
+     * @param {Highcharts.TimeNormalizeObject} normalizedInterval
+     * The interval in axis values (ms) and thecount.
+     *
+     * @param {number} min
+     * The minimum in axis values.
+     *
+     * @param {number} max
+     * The maximum in axis values.
+     *
+     * @param {number} startOfWeek
+     *
+     * @return {Highcharts.AxisTickPositionsArray}
      */
-    DateTimeAxisAdditions.prototype.normalizeTimeTickInterval = function (tickInterval, unitsOption) {
-        var units = unitsOption || [[
-                'millisecond',
-                [1, 2, 5, 10, 20, 25, 50, 100, 200, 500] // allowed multiples
-            ], [
-                'second',
-                [1, 2, 5, 10, 15, 30]
-            ], [
-                'minute',
-                [1, 2, 5, 10, 15, 30]
-            ], [
-                'hour',
-                [1, 2, 3, 4, 6, 8, 12]
-            ], [
-                'day',
-                [1, 2]
-            ], [
-                'week',
-                [1, 2]
-            ], [
-                'month',
-                [1, 2, 3, 4, 6]
-            ], [
-                'year',
-                null
-            ]], unit = units[units.length - 1], // default unit is years
-        interval = timeUnits[unit[0]], multiples = unit[1], count, i;
-        // loop through the units to find the one that best fits the
-        // tickInterval
-        for (i = 0; i < units.length; i++) {
-            unit = units[i];
-            interval = timeUnits[unit[0]];
-            multiples = unit[1];
-            if (units[i + 1]) {
-                // lessThan is in the middle between the highest multiple and
-                // the next unit.
-                var lessThan = (interval *
-                    multiples[multiples.length - 1] +
-                    timeUnits[units[i + 1][0]]) / 2;
-                // break and keep the current unit
-                if (tickInterval <= lessThan) {
-                    break;
-                }
-            }
+    function getTimeTicks() {
+        return this.chart.time.getTimeTicks.apply(this.chart.time, arguments);
+    }
+    /**
+     * @private
+     */
+    function onInit(e) {
+        var axis = this;
+        var options = e.userOptions;
+        if (options.type !== 'datetime') {
+            axis.dateTime = void 0;
+            return;
         }
-        // prevent 2.5 years intervals, though 25, 250 etc. are allowed
-        if (interval === timeUnits.year && tickInterval < 5 * interval) {
-            multiples = [1, 2, 5];
+        if (!axis.dateTime) {
+            axis.dateTime = new Additions(axis);
         }
-        // get the count
-        count = normalizeTickInterval(tickInterval / interval, multiples, unit[0] === 'year' ? // #1913, #2360
-            Math.max(getMagnitude(tickInterval / interval), 1) :
-            1);
-        return {
-            unitRange: interval,
-            count: count,
-            unitName: unit[0]
-        };
-    };
-    return DateTimeAxisAdditions;
-}());
-/**
- * Date and time support for axes.
- *
- * @private
- * @class
- */
-var DateTimeAxis = /** @class */ (function () {
-    function DateTimeAxis() {
     }
     /* *
      *
-     *  Static Functions
+     *  Classes
      *
      * */
-    /**
-     * Extends axis class with date and time support.
-     * @private
-     */
-    DateTimeAxis.compose = function (AxisClass) {
-        AxisClass.keepProps.push('dateTime');
-        var axisProto = AxisClass.prototype;
-        /**
-         * Set the tick positions to a time unit that makes sense, for example
-         * on the first of each month or on every Monday. Return an array with
-         * the time positions. Used in datetime axes as well as for grouping
-         * data on a datetime axis.
+    var Additions = /** @class */ (function () {
+        /* *
          *
-         * @private
-         * @function Highcharts.Axis#getTimeTicks
+         *  Constructors
          *
-         * @param {Highcharts.TimeNormalizeObject} normalizedInterval
-         * The interval in axis values (ms) and thecount.
+         * */
+        function Additions(axis) {
+            this.axis = axis;
+        }
+        /* *
          *
-         * @param {number} min
-         * The minimum in axis values.
+         *  Functions
          *
-         * @param {number} max
-         * The maximum in axis values.
+         * */
+        /**
+         * Get a normalized tick interval for dates. Returns a configuration
+         * object with unit range (interval), count and name. Used to prepare
+         * data for `getTimeTicks`. Previously this logic was part of
+         * getTimeTicks, but as `getTimeTicks` now runs of segments in stock
+         * charts, the normalizing logic was extracted in order to prevent it
+         * for running over again for each segment having the same interval.
+         * #662, #697.
+         * @private
+         */
+        Additions.prototype.normalizeTimeTickInterval = function (tickInterval, unitsOption) {
+            var units = (unitsOption || [[
+                    'millisecond',
+                    [1, 2, 5, 10, 20, 25, 50, 100, 200, 500] // allowed multiples
+                ], [
+                    'second',
+                    [1, 2, 5, 10, 15, 30]
+                ], [
+                    'minute',
+                    [1, 2, 5, 10, 15, 30]
+                ], [
+                    'hour',
+                    [1, 2, 3, 4, 6, 8, 12]
+                ], [
+                    'day',
+                    [1, 2]
+                ], [
+                    'week',
+                    [1, 2]
+                ], [
+                    'month',
+                    [1, 2, 3, 4, 6]
+                ], [
+                    'year',
+                    null
+                ]]);
+            var unit = units[units.length - 1], // default unit is years
+            interval = timeUnits[unit[0]], multiples = unit[1], i;
+            // loop through the units to find the one that best fits the
+            // tickInterval
+            for (i = 0; i < units.length; i++) {
+                unit = units[i];
+                interval = timeUnits[unit[0]];
+                multiples = unit[1];
+                if (units[i + 1]) {
+                    // lessThan is in the middle between the highest multiple
+                    // and the next unit.
+                    var lessThan = (interval *
+                        multiples[multiples.length - 1] +
+                        timeUnits[units[i + 1][0]]) / 2;
+                    // break and keep the current unit
+                    if (tickInterval <= lessThan) {
+                        break;
+                    }
+                }
+            }
+            // prevent 2.5 years intervals, though 25, 250 etc. are allowed
+            if (interval === timeUnits.year && tickInterval < 5 * interval) {
+                multiples = [1, 2, 5];
+            }
+            // get the count
+            var count = normalizeTickInterval(tickInterval / interval, multiples, unit[0] === 'year' ? // #1913, #2360
+                Math.max(getMagnitude(tickInterval / interval), 1) :
+                1);
+            return {
+                unitRange: interval,
+                count: count,
+                unitName: unit[0]
+            };
+        };
+        /**
+         * Get the best date format for a specific X value based on the closest
+         * point range on the axis.
          *
-         * @param {number} startOfWeek
+         * @private
+         *
+         * @param {number} x
          *
-         * @return {Highcharts.AxisTickPositionsArray}
+         * @param {Highcharts.Dictionary<string>} dateTimeLabelFormats
+         *
+         * @return {string}
          */
-        axisProto.getTimeTicks = function () {
-            return this.chart.time.getTimeTicks.apply(this.chart.time, arguments);
+        Additions.prototype.getXDateFormat = function (x, dateTimeLabelFormats) {
+            var axis = this.axis;
+            return axis.closestPointRange ?
+                axis.chart.time.getDateFormat(axis.closestPointRange, x, axis.options.startOfWeek, dateTimeLabelFormats) || dateTimeLabelFormats.year : // #2546, 2581
+                dateTimeLabelFormats.day;
         };
-        /* eslint-disable no-invalid-this */
-        addEvent(AxisClass, 'init', function (e) {
-            var axis = this;
-            var options = e.userOptions;
-            if (options.type !== 'datetime') {
-                axis.dateTime = void 0;
-                return;
-            }
-            if (!axis.dateTime) {
-                axis.dateTime = new DateTimeAxisAdditions(axis);
-            }
-        });
-        /* eslint-enable no-invalid-this */
-    };
-    /* *
-     *
-     *  Static Properties
-     *
-     * */
-    DateTimeAxis.AdditionsClass = DateTimeAxisAdditions;
-    return DateTimeAxis;
-}());
-DateTimeAxis.compose(Axis);
+        return Additions;
+    }());
+    DateTimeAxis.Additions = Additions;
+})(DateTimeAxis || (DateTimeAxis = {}));
+/* *
+ *
+ *  Default Export
+ *
+ * */
 export default DateTimeAxis;

package/es-modules/Core/Axis/GridAxis.js

@@ -364,11 +364,15 @@ var GridAxis;
                 (axis.scrollbar ||
                     (axis.linkedParent && axis.linkedParent.scrollbar))) {
                 var tickmarkOffset = axis.tickmarkOffset, lastTick = axis.tickPositions[axis.tickPositions.length - 1], firstTick = axis.tickPositions[0];
+                var label = void 0;
+                while ((label = axis.hiddenLabels.pop()) && label.element) {
+                    label.show(); // #15453
+                }
                 // Hide/show firts tick label.
-                var label = axis.ticks[firstTick].label;
+                label = axis.ticks[firstTick].label;
                 if (label) {
                     if (min - firstTick > tickmarkOffset) {
-                        label.hide();
+                        axis.hiddenLabels.push(label.hide());
                     }
                     else {
                         label.show();
@@ -378,7 +382,7 @@ var GridAxis;
                 label = axis.ticks[lastTick].label;
                 if (label) {
                     if (lastTick - max > tickmarkOffset) {
-                        label.hide();
+                        axis.hiddenLabels.push(label.hide());
                     }
                     else {
                         label.show();
@@ -670,6 +674,7 @@ var GridAxis;
         if (!axis.grid) {
             axis.grid = new Additions(axis);
         }
+        axis.hiddenLabels = [];
     }
     /**
      * Center tick labels in cells.

package/es-modules/Core/Axis/LogarithmicAxis.js

@@ -8,153 +8,195 @@
  *
  * */
 'use strict';
-import Axis from './Axis.js';
 import U from '../Utilities.js';
 var addEvent = U.addEvent, getMagnitude = U.getMagnitude, normalizeTickInterval = U.normalizeTickInterval, pick = U.pick;
-/* eslint-disable valid-jsdoc */
-/**
- * Provides logarithmic support for axes.
+/* *
+ *
+ *  Class
  *
+ * */
+/**
  * @private
- * @class
  */
-var LogarithmicAxisAdditions = /** @class */ (function () {
+var LogarithmicAxis;
+(function (LogarithmicAxis) {
     /* *
      *
-     *  Constructors
+     *  Declarations
      *
      * */
-    function LogarithmicAxisAdditions(axis) {
-        this.axis = axis;
-    }
+    /* *
+     *
+     *  Constants
+     *
+     * */
+    var composedClasses = [];
     /* *
      *
      *  Functions
      *
      * */
+    /* eslint-disable valid-jsdoc */
     /**
-     * Set the tick positions of a logarithmic axis.
+     * Provides logarithmic support for axes.
+     * @private
      */
-    LogarithmicAxisAdditions.prototype.getLogTickPositions = function (interval, min, max, minor) {
-        var log = this;
-        var axis = log.axis;
-        var axisLength = axis.len;
-        var options = axis.options;
-        // Since we use this method for both major and minor ticks,
-        // use a local variable and return the result
-        var positions = [];
-        // Reset
-        if (!minor) {
-            log.minorAutoInterval = void 0;
+    function compose(AxisClass) {
+        if (composedClasses.indexOf(AxisClass) === -1) {
+            composedClasses.push(AxisClass);
+            AxisClass.keepProps.push('logarithmic');
+            addEvent(AxisClass, 'init', onInit);
+            addEvent(AxisClass, 'afterInit', onAfterInit);
         }
-        // First case: All ticks fall on whole logarithms: 1, 10, 100 etc.
-        if (interval >= 0.5) {
-            interval = Math.round(interval);
-            positions = axis.getLinearTickPositions(interval, min, max);
-            // Second case: We need intermediary ticks. For example
-            // 1, 2, 4, 6, 8, 10, 20, 40 etc.
-        }
-        else if (interval >= 0.08) {
-            var roundedMin = Math.floor(min), intermediate = void 0, i = void 0, j = void 0, len = void 0, pos = void 0, lastPos = void 0, break2 = void 0;
-            if (interval > 0.3) {
-                intermediate = [1, 2, 4];
-                // 0.2 equals five minor ticks per 1, 10, 100 etc
-            }
-            else if (interval > 0.15) {
-                intermediate = [1, 2, 4, 6, 8];
-            }
-            else { // 0.1 equals ten minor ticks per 1, 10, 100 etc
-                intermediate = [1, 2, 3, 4, 5, 6, 7, 8, 9];
-            }
-            for (i = roundedMin; i < max + 1 && !break2; i++) {
-                len = intermediate.length;
-                for (j = 0; j < len && !break2; j++) {
-                    pos = log.log2lin(log.lin2log(i) * intermediate[j]);
-                    // #1670, lastPos is #3113
-                    if (pos > min &&
-                        (!minor || lastPos <= max) &&
-                        typeof lastPos !== 'undefined') {
-                        positions.push(lastPos);
-                    }
-                    if (lastPos > max) {
-                        break2 = true;
-                    }
-                    lastPos = pos;
-                }
-            }
-            // Third case: We are so deep in between whole logarithmic values that
-            // we might as well handle the tick positions like a linear axis. For
-            // example 1.01, 1.02, 1.03, 1.04.
+        return AxisClass;
+    }
+    LogarithmicAxis.compose = compose;
+    /**
+     * @private
+     */
+    function onInit(e) {
+        var axis = this;
+        var options = e.userOptions;
+        var logarithmic = axis.logarithmic;
+        if (options.type !== 'logarithmic') {
+            axis.logarithmic = void 0;
         }
         else {
-            var realMin = log.lin2log(min), realMax = log.lin2log(max), tickIntervalOption = minor ?
-                axis.getMinorTickInterval() :
-                options.tickInterval, filteredTickIntervalOption = tickIntervalOption === 'auto' ?
-                null :
-                tickIntervalOption, tickPixelIntervalOption = options.tickPixelInterval / (minor ? 5 : 1), totalPixelLength = minor ?
-                axisLength / axis.tickPositions.length :
-                axisLength;
-            interval = pick(filteredTickIntervalOption, log.minorAutoInterval, (realMax - realMin) *
-                tickPixelIntervalOption / (totalPixelLength || 1));
-            interval = normalizeTickInterval(interval, void 0, getMagnitude(interval));
-            positions = axis.getLinearTickPositions(interval, realMin, realMax).map(log.log2lin);
-            if (!minor) {
-                log.minorAutoInterval = interval / 5;
+            if (!logarithmic) {
+                logarithmic = axis.logarithmic = new Additions(axis);
             }
         }
-        // Set the axis-level tickInterval variable
-        if (!minor) {
-            axis.tickInterval = interval;
+    }
+    /**
+     * @private
+     */
+    function onAfterInit() {
+        var axis = this;
+        var log = axis.logarithmic;
+        // extend logarithmic axis
+        if (log) {
+            axis.lin2val = function (num) {
+                return log.lin2log(num);
+            };
+            axis.val2lin = function (num) {
+                return log.log2lin(num);
+            };
         }
-        return positions;
-    };
-    LogarithmicAxisAdditions.prototype.lin2log = function (num) {
-        return Math.pow(10, num);
-    };
-    LogarithmicAxisAdditions.prototype.log2lin = function (num) {
-        return Math.log(num) / Math.LN10;
-    };
-    return LogarithmicAxisAdditions;
-}());
-var LogarithmicAxis = /** @class */ (function () {
-    function LogarithmicAxis() {
     }
+    /* *
+     *
+     *  Class
+     *
+     * */
     /**
      * Provides logarithmic support for axes.
-     *
      * @private
+     * @class
      */
-    LogarithmicAxis.compose = function (AxisClass) {
-        AxisClass.keepProps.push('logarithmic');
-        /* eslint-disable no-invalid-this */
-        addEvent(AxisClass, 'init', function (e) {
-            var axis = this;
-            var options = e.userOptions;
-            var logarithmic = axis.logarithmic;
-            if (options.type !== 'logarithmic') {
-                axis.logarithmic = void 0;
+    var Additions = /** @class */ (function () {
+        /* *
+        *
+        *  Constructors
+        *
+        * */
+        function Additions(axis) {
+            this.axis = axis;
+        }
+        /* *
+        *
+        *  Functions
+        *
+        * */
+        /**
+         * Set the tick positions of a logarithmic axis.
+         */
+        Additions.prototype.getLogTickPositions = function (interval, min, max, minor) {
+            var log = this;
+            var axis = log.axis;
+            var axisLength = axis.len;
+            var options = axis.options;
+            // Since we use this method for both major and minor ticks,
+            // use a local variable and return the result
+            var positions = [];
+            // Reset
+            if (!minor) {
+                log.minorAutoInterval = void 0;
+            }
+            // First case: All ticks fall on whole logarithms: 1, 10, 100 etc.
+            if (interval >= 0.5) {
+                interval = Math.round(interval);
+                positions = axis.getLinearTickPositions(interval, min, max);
+                // Second case: We need intermediary ticks. For example
+                // 1, 2, 4, 6, 8, 10, 20, 40 etc.
+            }
+            else if (interval >= 0.08) {
+                var roundedMin = Math.floor(min);
+                var intermediate = void 0, i = void 0, j = void 0, len = void 0, pos = void 0, lastPos = void 0, break2 = void 0;
+                if (interval > 0.3) {
+                    intermediate = [1, 2, 4];
+                    // 0.2 equals five minor ticks per 1, 10, 100 etc
+                }
+                else if (interval > 0.15) {
+                    intermediate = [1, 2, 4, 6, 8];
+                }
+                else { // 0.1 equals ten minor ticks per 1, 10, 100 etc
+                    intermediate = [1, 2, 3, 4, 5, 6, 7, 8, 9];
+                }
+                for (i = roundedMin; i < max + 1 && !break2; i++) {
+                    len = intermediate.length;
+                    for (j = 0; j < len && !break2; j++) {
+                        pos = log.log2lin(log.lin2log(i) * intermediate[j]);
+                        // #1670, lastPos is #3113
+                        if (pos > min &&
+                            (!minor || lastPos <= max) &&
+                            typeof lastPos !== 'undefined') {
+                            positions.push(lastPos);
+                        }
+                        if (lastPos > max) {
+                            break2 = true;
+                        }
+                        lastPos = pos;
+                    }
+                }
+                // Third case: We are so deep in between whole logarithmic values,
+                // that we might as well handle the tick positions like a linear
+                // axis. For example 1.01, 1.02, 1.03, 1.04.
             }
             else {
-                if (!logarithmic) {
-                    logarithmic = axis.logarithmic = new LogarithmicAxisAdditions(axis);
+                var realMin = log.lin2log(min), realMax = log.lin2log(max), tickIntervalOption = minor ?
+                    axis.getMinorTickInterval() :
+                    options.tickInterval, filteredTickIntervalOption = tickIntervalOption === 'auto' ?
+                    null :
+                    tickIntervalOption, tickPixelIntervalOption = options.tickPixelInterval / (minor ? 5 : 1), totalPixelLength = minor ?
+                    axisLength / axis.tickPositions.length :
+                    axisLength;
+                interval = pick(filteredTickIntervalOption, log.minorAutoInterval, (realMax - realMin) *
+                    tickPixelIntervalOption / (totalPixelLength || 1));
+                interval = normalizeTickInterval(interval, void 0, getMagnitude(interval));
+                positions = axis.getLinearTickPositions(interval, realMin, realMax).map(log.log2lin);
+                if (!minor) {
+                    log.minorAutoInterval = interval / 5;
                 }
             }
-        });
-        addEvent(AxisClass, 'afterInit', function () {
-            var axis = this;
-            var log = axis.logarithmic;
-            // extend logarithmic axis
-            if (log) {
-                axis.lin2val = function (num) {
-                    return log.lin2log(num);
-                };
-                axis.val2lin = function (num) {
-                    return log.log2lin(num);
-                };
+            // Set the axis-level tickInterval variable
+            if (!minor) {
+                axis.tickInterval = interval;
             }
-        });
-    };
-    return LogarithmicAxis;
-}());
-LogarithmicAxis.compose(Axis); // @todo move to factory functions
+            return positions;
+        };
+        Additions.prototype.lin2log = function (num) {
+            return Math.pow(10, num);
+        };
+        Additions.prototype.log2lin = function (num) {
+            return Math.log(num) / Math.LN10;
+        };
+        return Additions;
+    }());
+    LogarithmicAxis.Additions = Additions;
+})(LogarithmicAxis || (LogarithmicAxis = {}));
+/* *
+ *
+ *  Default Export
+ *
+ * */
 export default LogarithmicAxis;