/** * @license Highcharts Gantt JS v8.1.0 (2020-05-05) * * GridAxis * * (c) 2016-2019 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, 'parts-gantt/GridAxis.js', [_modules['parts/Axis.js'], _modules['parts/Globals.js'], _modules['parts/Tick.js'], _modules['parts/Utilities.js']], function (Axis, H, Tick, 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 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; var argsToArray = function (args) { return Array.prototype.slice.call(args, 1); }, dateFormat = H.dateFormat, isObject = function (x) { // Always use strict mode return U.isObject(x, true); }, Chart = H.Chart; var applyGridOptions = 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; }; /** * 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} * @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 */ ''; // detach doclets above /** * Get the largest label width and height. * * @private * @function Highcharts.Axis#getMaxLabelDimensions * * @param {Highcharts.Dictionary} ticks * All the ticks on one axis. * * @param {Array} 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. */ Axis.prototype.getMaxLabelDimensions = function (ticks, tickPositions) { var dimensions = { width: 0, height: 0 }; tickPositions.forEach(function (pos) { var tick = ticks[pos], tickHeight = 0, tickWidth = 0, label; if (isObject(tick)) { label = isObject(tick.label) ? tick.label : {}; // Find width and height of tick tickHeight = label.getBBox ? label.getBBox().height : 0; if (label.textStr && !isNumber(label.textPxLength)) { label.textPxLength = label.getBBox().width; } tickWidth = isNumber(label.textPxLength) ? // Math.round ensures crisp lines Math.round(label.textPxLength) : 0; // Update the result if width and/or height are larger dimensions.height = Math.max(tickHeight, dimensions.height); dimensions.width = Math.max(tickWidth, dimensions.width); } }); return dimensions; }; // Adds week date format H.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(); }; // First letter of the day of the week, e.g. 'M' for 'Monday'. H.dateFormats.E = function (timestamp) { return dateFormat('%a', timestamp, true).charAt(0); }; /* eslint-disable no-invalid-this */ addEvent(Chart, 'afterSetChartSize', function () { this.axes.forEach(function (axis) { (axis.grid && axis.grid.columns || []).forEach(function (column) { column.setAxisSize(); column.setAxisTranslation(); }); }); }); // Center tick labels in cells. addEvent(Tick, 'afterGetLabelPosition', function (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 + tickmarkOffset), tickSize = axis.tickSize('tick'), tickWidth = tickSize ? tickSize[0] : 0, crispCorr = tickSize ? tickSize[1] / 2 : 0, 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); top = axis.top + axis.len - axis.translate(reversed ? tickPos : nextTickPos); } // 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)) - crispCorr; right = Math.round(axis.left + axis.translate(reversed ? tickPos : nextTickPos)) - crispCorr; } 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.element); labelHeight = label.getBBox().height; // 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); } }); /* eslint-enable no-invalid-this */ /** * Additions for grid axes. * @private * @class */ var GridAxisAdditions = /** @class */ (function () { /* * * * Constructors * * */ function GridAxisAdditions(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. */ GridAxisAdditions.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)); }; return GridAxisAdditions; }()); /** * Axis with grid support. * @private * @class */ var GridAxis = /** @class */ (function () { function GridAxis() { } /* * * * Static Functions * * */ /* eslint-disable valid-jsdoc */ /** * Extends axis class with grid support. * @private */ GridAxis.compose = function (AxisClass) { Axis.keepProps.push('grid'); wrap(AxisClass.prototype, 'unsquish', GridAxis.wrapUnsquish); // Add event handlers addEvent(AxisClass, 'init', GridAxis.onInit); addEvent(AxisClass, 'afterGetOffset', GridAxis.onAfterGetOffset); addEvent(AxisClass, 'afterGetTitlePosition', GridAxis.onAfterGetTitlePosition); addEvent(AxisClass, 'afterInit', GridAxis.onAfterInit); addEvent(AxisClass, 'afterRender', GridAxis.onAfterRender); addEvent(AxisClass, 'afterSetAxisTranslation', GridAxis.onAfterSetAxisTranslation); addEvent(AxisClass, 'afterSetOptions', GridAxis.onAfterSetOptions); addEvent(AxisClass, 'afterSetOptions', GridAxis.onAfterSetOptions2); addEvent(AxisClass, 'afterSetScale', GridAxis.onAfterSetScale); addEvent(AxisClass, 'afterTickSize', GridAxis.onAfterTickSize); addEvent(AxisClass, 'trimTicks', GridAxis.onTrimTicks); addEvent(AxisClass, 'destroy', GridAxis.onDestroy); }; /** * Handle columns and getOffset. * @private */ GridAxis.onAfterGetOffset = function () { var grid = this.grid; (grid && grid.columns || []).forEach(function (column) { column.getOffset(); }); }; /** * @private */ GridAxis.onAfterGetTitlePosition = function (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 title = axis.axisTitle, axisHeight = axis.height, horiz = axis.horiz, axisLeft = axis.left, offset = axis.offset, opposite = axis.opposite, _a = axis.options.title, axisTitleOptions = _a === void 0 ? {} : _a, axisTop = axis.top, axisWidth = axis.width; var tickSize = axis.tickSize(); var titleWidth = title && title.getBBox().width; var xOption = axisTitleOptions.x || 0; var yOption = axisTitleOptions.y || 0; var titleMargin = pick(axisTitleOptions.margin, horiz ? 5 : 10); var titleFontSize = axis.chart.renderer.fontMetrics(axisTitleOptions.style && axisTitleOptions.style.fontSize, title).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 / 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 */ GridAxis.onAfterInit = function () { var axis = this; var chart = axis.chart, _a = axis.options.grid, gridOptions = _a === void 0 ? {} : _a, userOptions = axis.userOptions; if (gridOptions.enabled) { applyGridOptions(axis); /* eslint-disable no-invalid-this */ // TODO: wrap the axis instead wrap(axis, 'labelFormatter', function (proceed) { var _a = this, axis = _a.axis, value = _a.value; var tickPos = axis.tickPositions; var series = (axis.isLinked ? 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; }); // Make additional properties available for the // formatter this.isFirst = isFirst; this.isLast = isLast; this.point = point; // Call original labelFormatter return proceed.call(this); }); /* eslint-enable no-invalid-this */ } if (gridOptions.columns) { var columns = axis.grid.columns = [], 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' }); 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 */ GridAxis.onAfterRender = function () { var axis = this; var grid = axis.grid; var options = axis.options; var renderer = axis.chart.renderer; var gridOptions = options.grid || {}; var yStartIndex, yEndIndex, xStartIndex, xEndIndex; if (gridOptions.enabled === true) { // @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); var startPoint = linePath[0]; var endPoint = linePath[1]; // Negate distance if top or left axis // Subtract 1px to draw the line at the end of the tick var tickLength = (axis.tickSize('tick') || [1])[0]; var 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 { // If axis is vertical, reposition line path // horizontally startPoint[1] += distance; endPoint[1] += distance; } } if (!axis.grid.axisLineExtra) { axis.grid.axisLineExtra = renderer .path(linePath) .attr({ zIndex: 7 }) .addClass('highcharts-axis-line') .add(axis.axisGroup); if (!renderer.styledMode) { axis.grid.axisLineExtra.attr({ stroke: options.lineColor, 'stroke-width': lineWidth }); } } else { 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(); }); } }; /** * @private */ GridAxis.onAfterSetAxisTranslation = function () { var axis = this; var tickInfo = axis.tickPositions && axis.tickPositions.info; var options = axis.options; var gridOptions = options.grid || {}; var userLabels = axis.userOptions.labels || {}; if (axis.horiz) { if (gridOptions.enabled === true) { 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; } } } }; /** * 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 */ GridAxis.onAfterSetOptions = function (e) { var options = this.options, userOptions = e.userOptions, gridAxisOptions, gridOptions = ((options && isObject(options.grid)) ? options.grid : {}); 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 unitIdx, count, unitName, i, units = gridAxisOptions.units, unitRange; for (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; } 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 */ GridAxis.onAfterSetOptions2 = function (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 */ GridAxis.onAfterSetScale = function () { 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 */ GridAxis.onAfterTickSize = function (e) { var defaultLeftAxisOptions = Axis.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 */ GridAxis.onDestroy = function (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 */ GridAxis.onInit = function (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 GridAxisAdditions(axis); } }; /** * 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? */ GridAxis.onTrimTicks = function () { 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 */ GridAxis.wrapUnsquish = function (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)); }; return GridAxis; }()); (function (GridAxis) { /** * 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 = {})); })(GridAxis || (GridAxis = {})); GridAxis.compose(Axis); return GridAxis; }); _registerModule(_modules, 'masters/modules/grid-axis.src.js', [], function () { }); }));