ps-toolkit-ui 0.0.207 → 0.0.211

package/src/assets/plugins/highcharts/code/modules/grid-axis.src.js

@@ -0,0 +1,1160 @@
+/**
+ * @license Highcharts Gantt JS v9.3.3 (2022-02-01)
+ *
+ * GridAxis
+ *
+ * (c) 2016-2021 Lars A. V. Cabrera
+ *
+ * License: www.highcharts.com/license
+ */
+'use strict';
+(function (factory) {
+    if (typeof module === 'object' && module.exports) {
+        factory['default'] = factory;
+        module.exports = factory;
+    } else if (typeof define === 'function' && define.amd) {
+        define('highcharts/modules/grid-axis', ['highcharts'], function (Highcharts) {
+            factory(Highcharts);
+            factory.Highcharts = Highcharts;
+            return factory;
+        });
+    } else {
+        factory(typeof Highcharts !== 'undefined' ? Highcharts : undefined);
+    }
+}(function (Highcharts) {
+    var _modules = Highcharts ? Highcharts._modules : {};
+    function _registerModule(obj, path, args, fn) {
+        if (!obj.hasOwnProperty(path)) {
+            obj[path] = fn.apply(null, args);
+        }
+    }
+    _registerModule(_modules, 'Core/Axis/GridAxis.js', [_modules['Core/Axis/Axis.js'], _modules['Core/Axis/AxisDefaults.js'], _modules['Core/Globals.js'], _modules['Core/Utilities.js']], function (Axis, AxisDefaults, H, U) {
+        /* *
+         *
+         *  (c) 2016 Highsoft AS
+         *  Authors: Lars A. V. Cabrera
+         *
+         *  License: www.highcharts.com/license
+         *
+         *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
+         *
+         * */
+        var dateFormats = H.dateFormats;
+        var addEvent = U.addEvent,
+            defined = U.defined,
+            erase = U.erase,
+            find = U.find,
+            isArray = U.isArray,
+            isNumber = U.isNumber,
+            merge = U.merge,
+            pick = U.pick,
+            timeUnits = U.timeUnits,
+            wrap = U.wrap;
+        /* *
+         *
+         *  Functions
+         *
+         * */
+        /* eslint-disable require-jsdoc */
+        function argsToArray(args) {
+            return Array.prototype.slice.call(args, 1);
+        }
+        function isObject(x) {
+            // Always use strict mode
+            return U.isObject(x, true);
+        }
+        function applyGridOptions(axis) {
+            var options = axis.options;
+            // Center-align by default
+            /*
+            if (!options.labels) {
+                options.labels = {};
+            }
+            */
+            options.labels.align = pick(options.labels.align, 'center');
+            // @todo: Check against tickLabelPlacement between/on etc
+            /* Prevents adding the last tick label if the axis is not a category
+               axis.
+               Since numeric labels are normally placed at starts and ends of a
+               range of value, and this module makes the label point at the value,
+               an "extra" label would appear. */
+            if (!axis.categories) {
+                options.showLastLabel = false;
+            }
+            // Prevents rotation of labels when squished, as rotating them would not
+            // help.
+            axis.labelRotation = 0;
+            options.labels.rotation = 0;
+        }
+        /**
+         * Axis with grid support.
+         * @private
+         */
+        var GridAxis;
+        (function (GridAxis) {
+            /* *
+             *
+             *  Declarations
+             *
+             * */
+            /**
+             * Enum for which side the axis is on. Maps to axis.side.
+             * @private
+             */
+            var Side;
+            (function (Side) {
+                Side[Side["top"] = 0] = "top";
+                Side[Side["right"] = 1] = "right";
+                Side[Side["bottom"] = 2] = "bottom";
+                Side[Side["left"] = 3] = "left";
+            })(Side = GridAxis.Side || (GridAxis.Side = {}));
+            /* *
+             *
+             *  Functions
+             *
+             * */
+            /* eslint-disable valid-jsdoc */
+            /**
+             * Extends axis class with grid support.
+             * @private
+             */
+            function compose(AxisClass, ChartClass, TickClass) {
+                if (AxisClass.keepProps.indexOf('grid') === -1) {
+                    AxisClass.keepProps.push('grid');
+                    AxisClass.prototype.getMaxLabelDimensions = getMaxLabelDimensions;
+                    wrap(AxisClass.prototype, 'unsquish', wrapUnsquish);
+                    // Add event handlers
+                    addEvent(AxisClass, 'init', onInit);
+                    addEvent(AxisClass, 'afterGetOffset', onAfterGetOffset);
+                    addEvent(AxisClass, 'afterGetTitlePosition', onAfterGetTitlePosition);
+                    addEvent(AxisClass, 'afterInit', onAfterInit);
+                    addEvent(AxisClass, 'afterRender', onAfterRender);
+                    addEvent(AxisClass, 'afterSetAxisTranslation', onAfterSetAxisTranslation);
+                    addEvent(AxisClass, 'afterSetOptions', onAfterSetOptions);
+                    addEvent(AxisClass, 'afterSetOptions', onAfterSetOptions2);
+                    addEvent(AxisClass, 'afterSetScale', onAfterSetScale);
+                    addEvent(AxisClass, 'afterTickSize', onAfterTickSize);
+                    addEvent(AxisClass, 'trimTicks', onTrimTicks);
+                    addEvent(AxisClass, 'destroy', onDestroy);
+                }
+                addEvent(ChartClass, 'afterSetChartSize', onChartAfterSetChartSize);
+                addEvent(TickClass, 'afterGetLabelPosition', onTickAfterGetLabelPosition);
+                addEvent(TickClass, 'labelFormat', onTickLabelFormat);
+                return AxisClass;
+            }
+            GridAxis.compose = compose;
+            /**
+             * Get the largest label width and height.
+             *
+             * @private
+             * @function Highcharts.Axis#getMaxLabelDimensions
+             *
+             * @param {Highcharts.Dictionary<Highcharts.Tick>} ticks
+             * All the ticks on one axis.
+             *
+             * @param {Array<number|string>} tickPositions
+             * All the tick positions on one axis.
+             *
+             * @return {Highcharts.SizeObject}
+             * Object containing the properties height and width.
+             *
+             * @todo Move this to the generic axis implementation, as it is used there.
+             */
+            function getMaxLabelDimensions(ticks, tickPositions) {
+                var dimensions = {
+                        width: 0,
+                        height: 0
+                    };
+                tickPositions.forEach(function (pos) {
+                    var tick = ticks[pos];
+                    var labelHeight = 0,
+                        labelWidth = 0,
+                        label;
+                    if (isObject(tick)) {
+                        label = isObject(tick.label) ? tick.label : {};
+                        // Find width and height of label
+                        labelHeight = label.getBBox ? label.getBBox().height : 0;
+                        if (label.textStr && !isNumber(label.textPxLength)) {
+                            label.textPxLength = label.getBBox().width;
+                        }
+                        labelWidth = isNumber(label.textPxLength) ?
+                            // Math.round ensures crisp lines
+                            Math.round(label.textPxLength) :
+                            0;
+                        if (label.textStr) {
+                            // Set the tickWidth same as the label width after ellipsis
+                            // applied #10281
+                            labelWidth = Math.round(label.getBBox().width);
+                        }
+                        // Update the result if width and/or height are larger
+                        dimensions.height = Math.max(labelHeight, dimensions.height);
+                        dimensions.width = Math.max(labelWidth, dimensions.width);
+                    }
+                });
+                // For tree grid, add indentation
+                if (this.options.type === 'treegrid' &&
+                    this.treeGrid &&
+                    this.treeGrid.mapOfPosToGridNode) {
+                    var treeDepth = this.treeGrid.mapOfPosToGridNode[-1].height || 0;
+                    dimensions.width += (this.options.labels.indentation *
+                        (treeDepth - 1));
+                }
+                return dimensions;
+            }
+            /**
+             * Handle columns and getOffset.
+             * @private
+             */
+            function onAfterGetOffset() {
+                var grid = this.grid;
+                (grid && grid.columns || []).forEach(function (column) {
+                    column.getOffset();
+                });
+            }
+            /**
+             * @private
+             */
+            function onAfterGetTitlePosition(e) {
+                var axis = this;
+                var options = axis.options;
+                var gridOptions = options.grid || {};
+                if (gridOptions.enabled === true) {
+                    // compute anchor points for each of the title align options
+                    var axisTitle = axis.axisTitle,
+                        axisHeight = axis.height,
+                        horiz = axis.horiz,
+                        axisLeft = axis.left,
+                        offset = axis.offset,
+                        opposite = axis.opposite,
+                        options_1 = axis.options,
+                        axisTop = axis.top,
+                        axisWidth = axis.width;
+                    var tickSize = axis.tickSize();
+                    var titleWidth = axisTitle && axisTitle.getBBox().width;
+                    var xOption = options_1.title.x;
+                    var yOption = options_1.title.y;
+                    var titleMargin = pick(options_1.title.margin,
+                        horiz ? 5 : 10);
+                    var titleFontSize = axis.chart.renderer.fontMetrics(options_1.title.style.fontSize,
+                        axisTitle).f;
+                    var crispCorr = tickSize ? tickSize[0] / 2 : 0;
+                    // TODO account for alignment
+                    // the position in the perpendicular direction of the axis
+                    var offAxis = ((horiz ? axisTop + axisHeight : axisLeft) +
+                            (horiz ? 1 : -1) * // horizontal axis reverses the margin
+                                (opposite ? -1 : 1) * // so does opposite axes
+                                crispCorr +
+                            (axis.side === GridAxis.Side.bottom ? titleFontSize : 0));
+                    e.titlePosition.x = horiz ?
+                        axisLeft - (titleWidth || 0) / 2 - titleMargin + xOption :
+                        offAxis + (opposite ? axisWidth : 0) + offset + xOption;
+                    e.titlePosition.y = horiz ?
+                        (offAxis -
+                            (opposite ? axisHeight : 0) +
+                            (opposite ? titleFontSize : -titleFontSize) / 2 +
+                            offset +
+                            yOption) :
+                        axisTop - titleMargin + yOption;
+                }
+            }
+            /**
+             * @private
+             */
+            function onAfterInit() {
+                var axis = this;
+                var chart = axis.chart,
+                    _a = axis.options.grid,
+                    gridOptions = _a === void 0 ? {} : _a,
+                    userOptions = axis.userOptions;
+                if (gridOptions.enabled) {
+                    applyGridOptions(axis);
+                }
+                if (gridOptions.columns) {
+                    var columns = axis.grid.columns = [];
+                    var columnIndex = axis.grid.columnIndex = 0;
+                    // Handle columns, each column is a grid axis
+                    while (++columnIndex < gridOptions.columns.length) {
+                        var columnOptions = merge(userOptions,
+                            gridOptions.columns[gridOptions.columns.length - columnIndex - 1], {
+                                linkedTo: 0,
+                                // Force to behave like category axis
+                                type: 'category',
+                                // Disable by default the scrollbar on the grid axis
+                                scrollbar: {
+                                    enabled: false
+                                }
+                            });
+                        delete columnOptions.grid.columns; // Prevent recursion
+                        var column = new Axis(axis.chart,
+                            columnOptions);
+                        column.grid.isColumn = true;
+                        column.grid.columnIndex = columnIndex;
+                        // Remove column axis from chart axes array, and place it
+                        // in the columns array.
+                        erase(chart.axes, column);
+                        erase(chart[axis.coll], column);
+                        columns.push(column);
+                    }
+                }
+            }
+            /**
+             * Draw an extra line on the far side of the outermost axis,
+             * creating floor/roof/wall of a grid. And some padding.
+             * ```
+             * Make this:
+             *             (axis.min) __________________________ (axis.max)
+             *                           |    |    |    |    |
+             * Into this:
+             *             (axis.min) __________________________ (axis.max)
+             *                        ___|____|____|____|____|__
+             * ```
+             * @private
+             */
+            function onAfterRender() {
+                var axis = this,
+                    grid = axis.grid,
+                    options = axis.options,
+                    gridOptions = options.grid || {};
+                if (gridOptions.enabled === true) {
+                    var min = axis.min || 0,
+                        max = axis.max || 0;
+                    // @todo acutual label padding (top, bottom, left, right)
+                    axis.maxLabelDimensions = axis.getMaxLabelDimensions(axis.ticks, axis.tickPositions);
+                    // Remove right wall before rendering if updating
+                    if (axis.rightWall) {
+                        axis.rightWall.destroy();
+                    }
+                    /*
+                    Draw an extra axis line on outer axes
+                                >
+                    Make this:    |______|______|______|___
+
+                                > _________________________
+                    Into this:    |______|______|______|__|
+                                                            */
+                    if (axis.grid && axis.grid.isOuterAxis() && axis.axisLine) {
+                        var lineWidth = options.lineWidth;
+                        if (lineWidth) {
+                            var linePath = axis.getLinePath(lineWidth),
+                                startPoint = linePath[0],
+                                endPoint = linePath[1], 
+                                // Negate distance if top or left axis
+                                // Subtract 1px to draw the line at the end of the tick
+                                tickLength = (axis.tickSize('tick') || [1])[0],
+                                distance = (tickLength - 1) * ((axis.side === GridAxis.Side.top ||
+                                    axis.side === GridAxis.Side.left) ? -1 : 1);
+                            // If axis is horizontal, reposition line path vertically
+                            if (startPoint[0] === 'M' && endPoint[0] === 'L') {
+                                if (axis.horiz) {
+                                    startPoint[2] += distance;
+                                    endPoint[2] += distance;
+                                }
+                                else {
+                                    startPoint[1] += distance;
+                                    endPoint[1] += distance;
+                                }
+                            }
+                            // If it doesn't exist, add an upper and lower border
+                            // for the vertical grid axis.
+                            if (!axis.horiz && axis.chart.marginRight) {
+                                var upperBorderStartPoint = startPoint,
+                                    upperBorderEndPoint = [
+                                        'L',
+                                        axis.left,
+                                        startPoint[2] || 0
+                                    ],
+                                    upperBorderPath = [
+                                        upperBorderStartPoint,
+                                        upperBorderEndPoint
+                                    ],
+                                    lowerBorderEndPoint = [
+                                        'L',
+                                        axis.chart.chartWidth - axis.chart.marginRight,
+                                        axis.toPixels(max + axis.tickmarkOffset)
+                                    ],
+                                    lowerBorderStartPoint = [
+                                        'M',
+                                        endPoint[1] || 0,
+                                        axis.toPixels(max + axis.tickmarkOffset)
+                                    ],
+                                    lowerBorderPath = [
+                                        lowerBorderStartPoint,
+                                        lowerBorderEndPoint
+                                    ];
+                                if (!axis.grid.upperBorder && min % 1 !== 0) {
+                                    axis.grid.upperBorder = axis.grid.renderBorder(upperBorderPath);
+                                }
+                                if (axis.grid.upperBorder) {
+                                    axis.grid.upperBorder.attr({
+                                        stroke: options.lineColor,
+                                        'stroke-width': options.lineWidth
+                                    });
+                                    axis.grid.upperBorder.animate({
+                                        d: upperBorderPath
+                                    });
+                                }
+                                if (!axis.grid.lowerBorder && max % 1 !== 0) {
+                                    axis.grid.lowerBorder = axis.grid.renderBorder(lowerBorderPath);
+                                }
+                                if (axis.grid.lowerBorder) {
+                                    axis.grid.lowerBorder.attr({
+                                        stroke: options.lineColor,
+                                        'stroke-width': options.lineWidth
+                                    });
+                                    axis.grid.lowerBorder.animate({
+                                        d: lowerBorderPath
+                                    });
+                                }
+                            }
+                            // Render an extra line parallel to the existing axes, to
+                            // close the grid.
+                            if (!axis.grid.axisLineExtra) {
+                                axis.grid.axisLineExtra = axis.grid.renderBorder(linePath);
+                            }
+                            else {
+                                axis.grid.axisLineExtra.attr({
+                                    stroke: options.lineColor,
+                                    'stroke-width': options.lineWidth
+                                });
+                                axis.grid.axisLineExtra.animate({
+                                    d: linePath
+                                });
+                            }
+                            // show or hide the line depending on options.showEmpty
+                            axis.axisLine[axis.showAxis ? 'show' : 'hide'](true);
+                        }
+                    }
+                    (grid && grid.columns || []).forEach(function (column) {
+                        column.render();
+                    });
+                    // Manipulate the tick mark visibility
+                    // based on the axis.max- allows smooth scrolling.
+                    if (!axis.horiz &&
+                        axis.chart.hasRendered &&
+                        (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.
+                        label = axis.ticks[firstTick].label;
+                        if (label) {
+                            if (min - firstTick > tickmarkOffset) {
+                                axis.hiddenLabels.push(label.hide());
+                            }
+                            else {
+                                label.show();
+                            }
+                        }
+                        // Hide/show last tick mark/label.
+                        label = axis.ticks[lastTick].label;
+                        if (label) {
+                            if (lastTick - max > tickmarkOffset) {
+                                axis.hiddenLabels.push(label.hide());
+                            }
+                            else {
+                                label.show();
+                            }
+                        }
+                        var mark = axis.ticks[lastTick].mark;
+                        if (mark) {
+                            if (lastTick - max < tickmarkOffset &&
+                                lastTick - max > 0 && axis.ticks[lastTick].isLast) {
+                                mark.hide();
+                            }
+                            else if (axis.ticks[lastTick - 1]) {
+                                mark.show();
+                            }
+                        }
+                    }
+                }
+            }
+            /**
+             * @private
+             */
+            function onAfterSetAxisTranslation() {
+                var axis = this;
+                var tickInfo = axis.tickPositions && axis.tickPositions.info;
+                var options = axis.options;
+                var gridOptions = options.grid || {};
+                var userLabels = axis.userOptions.labels || {};
+                // Fire this only for the Gantt type chart, #14868.
+                if (gridOptions.enabled) {
+                    if (axis.horiz) {
+                        axis.series.forEach(function (series) {
+                            series.options.pointRange = 0;
+                        });
+                        // Lower level time ticks, like hours or minutes, represent
+                        // points in time and not ranges. These should be aligned
+                        // left in the grid cell by default. The same applies to
+                        // years of higher order.
+                        if (tickInfo &&
+                            options.dateTimeLabelFormats &&
+                            options.labels &&
+                            !defined(userLabels.align) &&
+                            (options.dateTimeLabelFormats[tickInfo.unitName]
+                                .range === false ||
+                                tickInfo.count > 1 // years
+                            )) {
+                            options.labels.align = 'left';
+                            if (!defined(userLabels.x)) {
+                                options.labels.x = 3;
+                            }
+                        }
+                    }
+                    else {
+                        // Don't trim ticks which not in min/max range but
+                        // they are still in the min/max plus tickInterval.
+                        if (this.options.type !== 'treegrid' &&
+                            axis.grid &&
+                            axis.grid.columns) {
+                            this.minPointOffset = this.tickInterval;
+                        }
+                    }
+                }
+            }
+            /**
+             * Creates a left and right wall on horizontal axes:
+             * - Places leftmost tick at the start of the axis, to create a left
+             *   wall
+             * - Ensures that the rightmost tick is at the end of the axis, to
+             *   create a right wall.
+             * @private
+             */
+            function onAfterSetOptions(e) {
+                var options = this.options,
+                    userOptions = e.userOptions,
+                    gridOptions = ((options && isObject(options.grid)) ? options.grid : {});
+                var gridAxisOptions;
+                if (gridOptions.enabled === true) {
+                    // Merge the user options into default grid axis options so
+                    // that when a user option is set, it takes presedence.
+                    gridAxisOptions = merge(true, {
+                        className: ('highcharts-grid-axis ' + (userOptions.className || '')),
+                        dateTimeLabelFormats: {
+                            hour: {
+                                list: ['%H:%M', '%H']
+                            },
+                            day: {
+                                list: ['%A, %e. %B', '%a, %e. %b', '%E']
+                            },
+                            week: {
+                                list: ['Week %W', 'W%W']
+                            },
+                            month: {
+                                list: ['%B', '%b', '%o']
+                            }
+                        },
+                        grid: {
+                            borderWidth: 1
+                        },
+                        labels: {
+                            padding: 2,
+                            style: {
+                                fontSize: '13px'
+                            }
+                        },
+                        margin: 0,
+                        title: {
+                            text: null,
+                            reserveSpace: false,
+                            rotation: 0
+                        },
+                        // In a grid axis, only allow one unit of certain types,
+                        // for example we shouln't have one grid cell spanning
+                        // two days.
+                        units: [[
+                                'millisecond',
+                                [1, 10, 100]
+                            ], [
+                                'second',
+                                [1, 10]
+                            ], [
+                                'minute',
+                                [1, 5, 15]
+                            ], [
+                                'hour',
+                                [1, 6]
+                            ], [
+                                'day',
+                                [1]
+                            ], [
+                                'week',
+                                [1]
+                            ], [
+                                'month',
+                                [1]
+                            ], [
+                                'year',
+                                null
+                            ]]
+                    }, userOptions);
+                    // X-axis specific options
+                    if (this.coll === 'xAxis') {
+                        // For linked axes, tickPixelInterval is used only if
+                        // the tickPositioner below doesn't run or returns
+                        // undefined (like multiple years)
+                        if (defined(userOptions.linkedTo) &&
+                            !defined(userOptions.tickPixelInterval)) {
+                            gridAxisOptions.tickPixelInterval = 350;
+                        }
+                        // For the secondary grid axis, use the primary axis'
+                        // tick intervals and return ticks one level higher.
+                        if (
+                        // Check for tick pixel interval in options
+                        !defined(userOptions.tickPixelInterval) &&
+                            // Only for linked axes
+                            defined(userOptions.linkedTo) &&
+                            !defined(userOptions.tickPositioner) &&
+                            !defined(userOptions.tickInterval)) {
+                            gridAxisOptions.tickPositioner = function (min, max) {
+                                var parentInfo = (this.linkedParent &&
+                                        this.linkedParent.tickPositions &&
+                                        this.linkedParent.tickPositions.info);
+                                if (parentInfo) {
+                                    var units = (gridAxisOptions.units || []);
+                                    var unitIdx = void 0,
+                                        count = void 0,
+                                        unitName = void 0;
+                                    for (var i = 0; i < units.length; i++) {
+                                        if (units[i][0] ===
+                                            parentInfo.unitName) {
+                                            unitIdx = i;
+                                            break;
+                                        }
+                                    }
+                                    // Get the first allowed count on the next
+                                    // unit.
+                                    if (units[unitIdx + 1]) {
+                                        unitName = units[unitIdx + 1][0];
+                                        count =
+                                            (units[unitIdx + 1][1] || [1])[0];
+                                        // In case the base X axis shows years, make
+                                        // the secondary axis show ten times the
+                                        // years (#11427)
+                                    }
+                                    else if (parentInfo.unitName === 'year') {
+                                        unitName = 'year';
+                                        count = parentInfo.count * 10;
+                                    }
+                                    var unitRange = timeUnits[unitName];
+                                    this.tickInterval = unitRange * count;
+                                    return this.getTimeTicks({
+                                        unitRange: unitRange,
+                                        count: count,
+                                        unitName: unitName
+                                    }, min, max, this.options.startOfWeek);
+                                }
+                            };
+                        }
+                    }
+                    // Now merge the combined options into the axis options
+                    merge(true, this.options, gridAxisOptions);
+                    if (this.horiz) {
+                        /*               _________________________
+                        Make this:    ___|_____|_____|_____|__|
+                                        ^                     ^
+                                        _________________________
+                        Into this:    |_____|_____|_____|_____|
+                                            ^                 ^    */
+                        options.minPadding = pick(userOptions.minPadding, 0);
+                        options.maxPadding = pick(userOptions.maxPadding, 0);
+                    }
+                    // If borderWidth is set, then use its value for tick and
+                    // line width.
+                    if (isNumber(options.grid.borderWidth)) {
+                        options.tickWidth = options.lineWidth =
+                            gridOptions.borderWidth;
+                    }
+                }
+            }
+            /**
+             * @private
+             */
+            function onAfterSetOptions2(e) {
+                var axis = this;
+                var userOptions = e.userOptions;
+                var gridOptions = userOptions && userOptions.grid || {};
+                var columns = gridOptions.columns;
+                // Add column options to the parent axis. Children has their column
+                // options set on init in onGridAxisAfterInit.
+                if (gridOptions.enabled && columns) {
+                    merge(true, axis.options, columns[columns.length - 1]);
+                }
+            }
+            /**
+             * Handle columns and setScale.
+             * @private
+             */
+            function onAfterSetScale() {
+                var axis = this;
+                (axis.grid.columns || []).forEach(function (column) {
+                    column.setScale();
+                });
+            }
+            /**
+             * Draw vertical axis ticks extra long to create cell floors and roofs.
+             * Overrides the tickLength for vertical axes.
+             * @private
+             */
+            function onAfterTickSize(e) {
+                var defaultLeftAxisOptions = AxisDefaults.defaultLeftAxisOptions;
+                var _a = this,
+                    horiz = _a.horiz,
+                    maxLabelDimensions = _a.maxLabelDimensions,
+                    _b = _a.options.grid,
+                    gridOptions = _b === void 0 ? {} : _b;
+                if (gridOptions.enabled && maxLabelDimensions) {
+                    var labelPadding = (Math.abs(defaultLeftAxisOptions.labels.x) * 2);
+                    var distance = horiz ?
+                            (gridOptions.cellHeight ||
+                                labelPadding + maxLabelDimensions.height) :
+                            labelPadding + maxLabelDimensions.width;
+                    if (isArray(e.tickSize)) {
+                        e.tickSize[0] = distance;
+                    }
+                    else {
+                        e.tickSize = [distance, 0];
+                    }
+                }
+            }
+            /**
+             * @private
+             */
+            function onChartAfterSetChartSize() {
+                this.axes.forEach(function (axis) {
+                    (axis.grid && axis.grid.columns || []).forEach(function (column) {
+                        column.setAxisSize();
+                        column.setAxisTranslation();
+                    });
+                });
+            }
+            /**
+             * @private
+             */
+            function onDestroy(e) {
+                var grid = this.grid;
+                (grid.columns || []).forEach(function (column) {
+                    column.destroy(e.keepEvents);
+                });
+                grid.columns = void 0;
+            }
+            /**
+             * Wraps axis init to draw cell walls on vertical axes.
+             * @private
+             */
+            function onInit(e) {
+                var axis = this;
+                var userOptions = e.userOptions || {};
+                var gridOptions = userOptions.grid || {};
+                if (gridOptions.enabled && defined(gridOptions.borderColor)) {
+                    userOptions.tickColor = userOptions.lineColor = (gridOptions.borderColor);
+                }
+                if (!axis.grid) {
+                    axis.grid = new Additions(axis);
+                }
+                axis.hiddenLabels = [];
+            }
+            /**
+             * Center tick labels in cells.
+             * @private
+             */
+            function onTickAfterGetLabelPosition(e) {
+                var tick = this,
+                    label = tick.label,
+                    axis = tick.axis,
+                    reversed = axis.reversed,
+                    chart = axis.chart,
+                    options = axis.options,
+                    gridOptions = options.grid || {},
+                    labelOpts = axis.options.labels,
+                    align = labelOpts.align, 
+                    // verticalAlign is currently not supported for axis.labels.
+                    verticalAlign = 'middle', // labelOpts.verticalAlign,
+                    side = GridAxis.Side[axis.side],
+                    tickmarkOffset = e.tickmarkOffset,
+                    tickPositions = axis.tickPositions,
+                    tickPos = tick.pos - tickmarkOffset,
+                    nextTickPos = (isNumber(tickPositions[e.index + 1]) ?
+                        tickPositions[e.index + 1] - tickmarkOffset :
+                        (axis.max || 0) + tickmarkOffset),
+                    tickSize = axis.tickSize('tick'),
+                    tickWidth = tickSize ? tickSize[0] : 0,
+                    crispCorr = tickSize ? tickSize[1] / 2 : 0;
+                var labelHeight,
+                    lblMetrics,
+                    lines,
+                    bottom,
+                    top,
+                    left,
+                    right;
+                // Only center tick labels in grid axes
+                if (gridOptions.enabled === true) {
+                    // Calculate top and bottom positions of the cell.
+                    if (side === 'top') {
+                        bottom = axis.top + axis.offset;
+                        top = bottom - tickWidth;
+                    }
+                    else if (side === 'bottom') {
+                        top = chart.chartHeight - axis.bottom + axis.offset;
+                        bottom = top + tickWidth;
+                    }
+                    else {
+                        bottom = axis.top + axis.len - (axis.translate(reversed ? nextTickPos : tickPos) || 0);
+                        top = axis.top + axis.len - (axis.translate(reversed ? tickPos : nextTickPos) || 0);
+                    }
+                    // Calculate left and right positions of the cell.
+                    if (side === 'right') {
+                        left = chart.chartWidth - axis.right + axis.offset;
+                        right = left + tickWidth;
+                    }
+                    else if (side === 'left') {
+                        right = axis.left + axis.offset;
+                        left = right - tickWidth;
+                    }
+                    else {
+                        left = Math.round(axis.left + (axis.translate(reversed ? nextTickPos : tickPos) || 0)) - crispCorr;
+                        right = Math.min(// #15742
+                        Math.round(axis.left + (axis.translate(reversed ? tickPos : nextTickPos) || 0)) - crispCorr, axis.left + axis.len);
+                    }
+                    tick.slotWidth = right - left;
+                    // Calculate the positioning of the label based on
+                    // alignment.
+                    e.pos.x = (align === 'left' ?
+                        left :
+                        align === 'right' ?
+                            right :
+                            left + ((right - left) / 2) // default to center
+                    );
+                    e.pos.y = (verticalAlign === 'top' ?
+                        top :
+                        verticalAlign === 'bottom' ?
+                            bottom :
+                            top + ((bottom - top) / 2) // default to middle
+                    );
+                    lblMetrics = chart.renderer.fontMetrics(labelOpts.style.fontSize, label && label.element);
+                    labelHeight = label ? label.getBBox().height : 0;
+                    // Adjustment to y position to align the label correctly.
+                    // Would be better to have a setter or similar for this.
+                    if (!labelOpts.useHTML) {
+                        lines = Math.round(labelHeight / lblMetrics.h);
+                        e.pos.y += (
+                        // Center the label
+                        // TODO: why does this actually center the label?
+                        ((lblMetrics.b - (lblMetrics.h - lblMetrics.f)) / 2) +
+                            // Adjust for height of additional lines.
+                            -(((lines - 1) * lblMetrics.h) / 2));
+                    }
+                    else {
+                        e.pos.y += (
+                        // Readjust yCorr in htmlUpdateTransform
+                        lblMetrics.b +
+                            // Adjust for height of html label
+                            -(labelHeight / 2));
+                    }
+                    e.pos.x += (axis.horiz && labelOpts.x) || 0;
+                }
+            }
+            /**
+             * @private
+             */
+            function onTickLabelFormat(ctx) {
+                var axis = ctx.axis,
+                    value = ctx.value;
+                if (axis.options.grid &&
+                    axis.options.grid.enabled) {
+                    var tickPos = axis.tickPositions;
+                    var series = (axis.linkedParent || axis).series[0];
+                    var isFirst = value === tickPos[0];
+                    var isLast = value === tickPos[tickPos.length - 1];
+                    var point = series && find(series.options.data,
+                        function (p) {
+                            return p[axis.isXAxis ? 'x' : 'y'] === value;
+                    });
+                    var pointCopy = void 0;
+                    if (point && series.is('gantt')) {
+                        // For the Gantt set point aliases to the pointCopy
+                        // to do not change the original point
+                        pointCopy = merge(point);
+                        H.seriesTypes.gantt.prototype.pointClass
+                            .setGanttPointAliases(pointCopy);
+                    }
+                    // Make additional properties available for the
+                    // formatter
+                    ctx.isFirst = isFirst;
+                    ctx.isLast = isLast;
+                    ctx.point = pointCopy;
+                }
+            }
+            /**
+             * Makes tick labels which are usually ignored in a linked axis
+             * displayed if they are within range of linkedParent.min.
+             * ```
+             *                        _____________________________
+             *                        |   |       |       |       |
+             * Make this:             |   |   2   |   3   |   4   |
+             *                        |___|_______|_______|_______|
+             *                          ^
+             *                        _____________________________
+             *                        |   |       |       |       |
+             * Into this:             | 1 |   2   |   3   |   4   |
+             *                        |___|_______|_______|_______|
+             *                          ^
+             * ```
+             * @private
+             * @todo Does this function do what the drawing says? Seems to affect
+             *       ticks and not the labels directly?
+             */
+            function onTrimTicks() {
+                var axis = this;
+                var options = axis.options;
+                var gridOptions = options.grid || {};
+                var categoryAxis = axis.categories;
+                var tickPositions = axis.tickPositions;
+                var firstPos = tickPositions[0];
+                var lastPos = tickPositions[tickPositions.length - 1];
+                var linkedMin = axis.linkedParent && axis.linkedParent.min;
+                var linkedMax = axis.linkedParent && axis.linkedParent.max;
+                var min = linkedMin || axis.min;
+                var max = linkedMax || axis.max;
+                var tickInterval = axis.tickInterval;
+                var endMoreThanMin = (firstPos < min &&
+                        firstPos + tickInterval > min);
+                var startLessThanMax = (lastPos > max &&
+                        lastPos - tickInterval < max);
+                if (gridOptions.enabled === true &&
+                    !categoryAxis &&
+                    (axis.horiz || axis.isLinked)) {
+                    if (endMoreThanMin && !options.startOnTick) {
+                        tickPositions[0] = min;
+                    }
+                    if (startLessThanMax && !options.endOnTick) {
+                        tickPositions[tickPositions.length - 1] = max;
+                    }
+                }
+            }
+            /**
+             * Avoid altering tickInterval when reserving space.
+             * @private
+             */
+            function wrapUnsquish(proceed) {
+                var axis = this;
+                var _a = axis.options.grid,
+                    gridOptions = _a === void 0 ? {} : _a;
+                if (gridOptions.enabled === true && axis.categories) {
+                    return axis.tickInterval;
+                }
+                return proceed.apply(axis, argsToArray(arguments));
+            }
+            /* *
+             *
+             *  Class
+             *
+             * */
+            /**
+             * Additions for grid axes.
+             * @private
+             * @class
+             */
+            var Additions = /** @class */ (function () {
+                    /* *
+                    *
+                    *  Constructors
+                    *
+                    * */
+                    function Additions(axis) {
+                        this.axis = axis;
+                }
+                /* *
+                *
+                *  Functions
+                *
+                * */
+                /**
+                 * Checks if an axis is the outer axis in its dimension. Since
+                 * axes are placed outwards in order, the axis with the highest
+                 * index is the outermost axis.
+                 *
+                 * Example: If there are multiple x-axes at the top of the chart,
+                 * this function returns true if the axis supplied is the last
+                 * of the x-axes.
+                 *
+                 * @private
+                 *
+                 * @return {boolean}
+                 * True if the axis is the outermost axis in its dimension; false if
+                 * not.
+                 */
+                Additions.prototype.isOuterAxis = function () {
+                    var axis = this.axis;
+                    var chart = axis.chart;
+                    var columnIndex = axis.grid.columnIndex;
+                    var columns = (axis.linkedParent && axis.linkedParent.grid.columns ||
+                            axis.grid.columns);
+                    var parentAxis = columnIndex ? axis.linkedParent : axis;
+                    var thisIndex = -1,
+                        lastIndex = 0;
+                    chart[axis.coll].forEach(function (otherAxis, index) {
+                        if (otherAxis.side === axis.side &&
+                            !otherAxis.options.isInternal) {
+                            lastIndex = index;
+                            if (otherAxis === parentAxis) {
+                                // Get the index of the axis in question
+                                thisIndex = index;
+                            }
+                        }
+                    });
+                    return (lastIndex === thisIndex &&
+                        (isNumber(columnIndex) ?
+                            columns.length === columnIndex :
+                            true));
+                };
+                /**
+                 * Add extra border based on the provided path.
+                 * @private
+                 * @param {SVGPath} path
+                 * The path of the border.
+                 * @return {Highcharts.SVGElement}
+                 * Border
+                 */
+                Additions.prototype.renderBorder = function (path) {
+                    var axis = this.axis,
+                        renderer = axis.chart.renderer,
+                        options = axis.options,
+                        extraBorderLine = renderer.path(path)
+                            .addClass('highcharts-axis-line')
+                            .add(axis.axisBorder);
+                    if (!renderer.styledMode) {
+                        extraBorderLine.attr({
+                            stroke: options.lineColor,
+                            'stroke-width': options.lineWidth,
+                            zIndex: 7
+                        });
+                    }
+                    return extraBorderLine;
+                };
+                return Additions;
+            }());
+            GridAxis.Additions = Additions;
+        })(GridAxis || (GridAxis = {}));
+        /* *
+         *
+         *  Registry
+         *
+         * */
+        // First letter of the day of the week, e.g. 'M' for 'Monday'.
+        dateFormats.E = function (timestamp) {
+            return this.dateFormat('%a', timestamp, true).charAt(0);
+        };
+        // Adds week date format
+        dateFormats.W = function (timestamp) {
+            var d = new this.Date(timestamp);
+            var firstDay = (this.get('Day',
+                d) + 6) % 7;
+            var thursday = new this.Date(d.valueOf());
+            this.set('Date', thursday, this.get('Date', d) - firstDay + 3);
+            var firstThursday = new this.Date(this.get('FullYear',
+                thursday), 0, 1);
+            if (this.get('Day', firstThursday) !== 4) {
+                this.set('Month', d, 0);
+                this.set('Date', d, 1 + (11 - this.get('Day', firstThursday)) % 7);
+            }
+            return (1 +
+                Math.floor((thursday.valueOf() - firstThursday.valueOf()) / 604800000)).toString();
+        };
+        /* *
+         *
+         *  Default Export
+         *
+         * */
+        /* *
+         *
+         *  API Options
+         *
+         * */
+        /**
+         * @productdesc {gantt}
+         * For grid axes (like in Gantt charts),
+         * it is possible to declare as a list to provide different
+         * formats depending on available space.
+         *
+         * Defaults to:
+         * ```js
+         * {
+         *     hour: { list: ['%H:%M', '%H'] },
+         *     day: { list: ['%A, %e. %B', '%a, %e. %b', '%E'] },
+         *     week: { list: ['Week %W', 'W%W'] },
+         *     month: { list: ['%B', '%b', '%o'] }
+         * }
+         * ```
+         *
+         * @sample {gantt} gantt/grid-axis/date-time-label-formats
+         *         Gantt chart with custom axis date format.
+         *
+         * @apioption xAxis.dateTimeLabelFormats
+         */
+        /**
+         * Set grid options for the axis labels. Requires Highcharts Gantt.
+         *
+         * @since     6.2.0
+         * @product   gantt
+         * @apioption xAxis.grid
+         */
+        /**
+         * Enable grid on the axis labels. Defaults to true for Gantt charts.
+         *
+         * @type      {boolean}
+         * @default   true
+         * @since     6.2.0
+         * @product   gantt
+         * @apioption xAxis.grid.enabled
+         */
+        /**
+         * Set specific options for each column (or row for horizontal axes) in the
+         * grid. Each extra column/row is its own axis, and the axis options can be set
+         * here.
+         *
+         * @sample gantt/demo/left-axis-table
+         *         Left axis as a table
+         *
+         * @type      {Array<Highcharts.XAxisOptions>}
+         * @apioption xAxis.grid.columns
+         */
+        /**
+         * Set border color for the label grid lines.
+         *
+         * @type      {Highcharts.ColorString}
+         * @apioption xAxis.grid.borderColor
+         */
+        /**
+         * Set border width of the label grid lines.
+         *
+         * @type      {number}
+         * @default   1
+         * @apioption xAxis.grid.borderWidth
+         */
+        /**
+         * Set cell height for grid axis labels. By default this is calculated from font
+         * size. This option only applies to horizontal axes.
+         *
+         * @sample gantt/grid-axis/cellheight
+         *         Gant chart with custom cell height
+         * @type      {number}
+         * @apioption xAxis.grid.cellHeight
+         */
+        ''; // keeps doclets above in JS file
+
+        return GridAxis;
+    });
+    _registerModule(_modules, 'masters/modules/grid-axis.src.js', [_modules['Core/Globals.js'], _modules['Core/Axis/GridAxis.js']], function (Highcharts, GridAxis) {
+
+        var G = Highcharts;
+        // Compositions
+        GridAxis.compose(G.Axis, G.Chart, G.Tick);
+
+    });
+}));