devextreme
Version:
HTML5 JavaScript Component Suite for Responsive Web Development
1,162 lines (1,144 loc) • 104 kB
JavaScript
/**
* DevExtreme (esm/viz/axes/base_axis.js)
* Version: 21.1.4
* Build date: Mon Jun 21 2021
*
* Copyright (c) 2012 - 2021 Developer Express Inc. ALL RIGHTS RESERVED
* Read about DevExtreme licensing here: https://js.devexpress.com/Licensing/
*/
import {
smartFormatter as _format,
formatRange
} from "./smart_formatter";
import {
patchFontOptions,
getVizRangeObject,
getLogExt as getLog,
raiseToExt as raiseTo,
valueOf,
rotateBBox,
getCategoriesInfo,
adjustVisualRange,
getAddFunction,
convertVisualRangeObject
} from "../core/utils";
import {
isDefined,
isFunction,
isPlainObject,
type
} from "../../core/utils/type";
import constants from "./axes_constants";
import {
extend
} from "../../core/utils/extend";
import {
inArray
} from "../../core/utils/array";
import formatHelper from "../../format_helper";
import {
getParser
} from "../components/parse_utils";
import {
tickGenerator
} from "./tick_generator";
import {
Translator2D
} from "../translators/translator2d";
import {
Range
} from "../translators/range";
import {
tick
} from "./tick";
import {
adjust
} from "../../core/utils/math";
import dateUtils from "../../core/utils/date";
import {
noop as _noop
} from "../../core/utils/common";
import xyMethods from "./xy_axes";
import * as polarMethods from "./polar_axes";
import createConstantLine from "./constant_line";
import createStrip from "./strip";
import {
Deferred,
when
} from "../../core/utils/deferred";
import {
calculateCanvasMargins,
measureLabels
} from "./axes_utils";
var convertTicksToValues = constants.convertTicksToValues;
var _math = Math;
var _abs = _math.abs;
var _max = _math.max;
var _min = _math.min;
var _isArray = Array.isArray;
var DEFAULT_AXIS_LABEL_SPACING = 5;
var MAX_GRID_BORDER_ADHENSION = 4;
var TOP = constants.top;
var BOTTOM = constants.bottom;
var LEFT = constants.left;
var RIGHT = constants.right;
var CENTER = constants.center;
var KEEP = "keep";
var SHIFT = "shift";
var RESET = "reset";
var ROTATE = "rotate";
var DEFAULT_AXIS_DIVISION_FACTOR = 50;
var DEFAULT_MINOR_AXIS_DIVISION_FACTOR = 15;
var SCROLL_THRESHOLD = 5;
var MIN_BAR_MARGIN = 5;
var MAX_MARGIN_VALUE = .8;
var dateIntervals = {
day: 864e5,
week: 6048e5
};
function getTickGenerator(options, incidentOccurred, skipTickGeneration, rangeIsEmpty, adjustDivisionFactor, _ref) {
var _options$workWeek;
var {
allowNegatives: allowNegatives,
linearThreshold: linearThreshold
} = _ref;
return tickGenerator({
axisType: options.type,
dataType: options.dataType,
logBase: options.logarithmBase,
allowNegatives: allowNegatives,
linearThreshold: linearThreshold,
axisDivisionFactor: adjustDivisionFactor(options.axisDivisionFactor || DEFAULT_AXIS_DIVISION_FACTOR),
minorAxisDivisionFactor: adjustDivisionFactor(options.minorAxisDivisionFactor || DEFAULT_MINOR_AXIS_DIVISION_FACTOR),
numberMultipliers: options.numberMultipliers,
calculateMinors: options.minorTick.visible || options.minorGrid.visible || options.calculateMinors,
allowDecimals: options.allowDecimals,
endOnTick: options.endOnTick,
incidentOccurred: incidentOccurred,
firstDayOfWeek: null === (_options$workWeek = options.workWeek) || void 0 === _options$workWeek ? void 0 : _options$workWeek[0],
skipTickGeneration: skipTickGeneration,
skipCalculationLimits: options.skipCalculationLimits,
generateExtraTick: options.generateExtraTick,
minTickInterval: options.minTickInterval,
rangeIsEmpty: rangeIsEmpty
})
}
function createMajorTick(axis, renderer, skippedCategory) {
var options = axis.getOptions();
return tick(axis, renderer, options.tick, options.grid, skippedCategory, false)
}
function createMinorTick(axis, renderer) {
var options = axis.getOptions();
return tick(axis, renderer, options.minorTick, options.minorGrid)
}
function createBoundaryTick(axis, renderer, isFirst) {
var options = axis.getOptions();
return tick(axis, renderer, extend({}, options.tick, {
visible: options.showCustomBoundaryTicks
}), options.grid, void 0, false, isFirst ? -1 : 1)
}
function callAction(elements, action, actionArgument1, actionArgument2) {
(elements || []).forEach(e => e[action](actionArgument1, actionArgument2))
}
function initTickCoords(ticks) {
callAction(ticks, "initCoords")
}
function drawTickMarks(ticks, options) {
callAction(ticks, "drawMark", options)
}
function drawGrids(ticks, drawLine) {
callAction(ticks, "drawGrid", drawLine)
}
function updateTicksPosition(ticks, options, animate) {
callAction(ticks, "updateTickPosition", options, animate)
}
function updateGridsPosition(ticks, animate) {
callAction(ticks, "updateGridPosition", animate)
}
function cleanUpInvalidTicks(ticks) {
var i = ticks.length - 1;
for (i; i >= 0; i--) {
if (!removeInvalidTick(ticks, i)) {
break
}
}
for (i = 0; i < ticks.length; i++) {
if (removeInvalidTick(ticks, i)) {
i--
} else {
break
}
}
}
function removeInvalidTick(ticks, i) {
if (null === ticks[i].coords.x || null === ticks[i].coords.y) {
ticks.splice(i, 1);
return true
}
return false
}
function validateAxisOptions(options) {
var _labelOptions$minSpac;
var labelOptions = options.label;
var position = options.position;
var defaultPosition = options.isHorizontal ? BOTTOM : LEFT;
var secondaryPosition = options.isHorizontal ? TOP : RIGHT;
var labelPosition = labelOptions.position;
if (position !== defaultPosition && position !== secondaryPosition) {
position = defaultPosition
}
if (!labelPosition || "outside" === labelPosition) {
labelPosition = position
} else if ("inside" === labelPosition) {
labelPosition = {
[TOP]: BOTTOM,
[BOTTOM]: TOP,
[LEFT]: RIGHT,
[RIGHT]: LEFT
} [position]
}
if (labelPosition !== defaultPosition && labelPosition !== secondaryPosition) {
labelPosition = position
}
if (labelOptions.alignment !== CENTER && !labelOptions.userAlignment) {
labelOptions.alignment = {
[TOP]: CENTER,
[BOTTOM]: CENTER,
[LEFT]: RIGHT,
[RIGHT]: LEFT
} [labelPosition]
}
options.position = position;
labelOptions.position = labelPosition;
options.hoverMode = options.hoverMode ? options.hoverMode.toLowerCase() : "none";
labelOptions.minSpacing = null !== (_labelOptions$minSpac = labelOptions.minSpacing) && void 0 !== _labelOptions$minSpac ? _labelOptions$minSpac : DEFAULT_AXIS_LABEL_SPACING;
options.type && (options.type = options.type.toLowerCase());
options.argumentType && (options.argumentType = options.argumentType.toLowerCase());
options.valueType && (options.valueType = options.valueType.toLowerCase())
}
function getOptimalAngle(boxes, labelOpt) {
var angle = 180 * _math.asin((boxes[0].height + labelOpt.minSpacing) / (boxes[1].x - boxes[0].x)) / _math.PI;
return angle < 45 ? -45 : -90
}
function updateLabels(ticks, step, func) {
ticks.forEach((function(tick, index) {
if (tick.getContentContainer()) {
if (index % step !== 0) {
tick.removeLabel()
} else if (func) {
func(tick, index)
}
}
}))
}
function getZoomBoundValue(optionValue, dataValue) {
if (void 0 === optionValue) {
return dataValue
} else if (null === optionValue) {
return
} else {
return optionValue
}
}
function configureGenerator(options, axisDivisionFactor, viewPort, screenDelta, minTickInterval) {
var tickGeneratorOptions = extend({}, options, {
endOnTick: true,
axisDivisionFactor: axisDivisionFactor,
skipCalculationLimits: true,
generateExtraTick: true,
minTickInterval: minTickInterval
});
return function(tickInterval, skipTickGeneration, min, max, breaks) {
return getTickGenerator(tickGeneratorOptions, _noop, skipTickGeneration, viewPort.isEmpty(), v => v, viewPort)({
min: min,
max: max,
categories: viewPort.categories,
isSpacedMargin: viewPort.isSpacedMargin
}, screenDelta, tickInterval, isDefined(tickInterval), void 0, void 0, void 0, breaks)
}
}
function getConstantLineSharpDirection(coord, axisCanvas) {
return Math.max(axisCanvas.start, axisCanvas.end) !== coord ? 1 : -1
}
export var Axis = function(renderSettings) {
this._renderer = renderSettings.renderer;
this._incidentOccurred = renderSettings.incidentOccurred;
this._eventTrigger = renderSettings.eventTrigger;
this._stripsGroup = renderSettings.stripsGroup;
this._stripLabelAxesGroup = renderSettings.stripLabelAxesGroup;
this._labelsAxesGroup = renderSettings.labelsAxesGroup;
this._constantLinesGroup = renderSettings.constantLinesGroup;
this._scaleBreaksGroup = renderSettings.scaleBreaksGroup;
this._axesContainerGroup = renderSettings.axesContainerGroup;
this._gridContainerGroup = renderSettings.gridGroup;
this._axisCssPrefix = renderSettings.widgetClass + "-" + (renderSettings.axisClass ? renderSettings.axisClass + "-" : "");
this._setType(renderSettings.axisType, renderSettings.drawingType);
this._createAxisGroups();
this._translator = this._createTranslator();
this.isArgumentAxis = renderSettings.isArgumentAxis;
this._viewport = {};
this._firstDrawing = true;
this._initRange = {};
this._getTemplate = renderSettings.getTemplate
};
Axis.prototype = {
constructor: Axis,
_drawAxis() {
var options = this._options;
if (!options.visible) {
return
}
this._axisElement = this._createAxisElement();
this._updateAxisElementPosition();
this._axisElement.attr({
"stroke-width": options.width,
stroke: options.color,
"stroke-opacity": options.opacity
}).sharp(this._getSharpParam(true), this.getAxisSharpDirection()).append(this._axisLineGroup)
},
_createPathElement(points, attr, sharpDirection) {
return this.sharp(this._renderer.path(points, "line").attr(attr), sharpDirection)
},
sharp(svgElement) {
var sharpDirection = arguments.length > 1 && void 0 !== arguments[1] ? arguments[1] : 1;
return svgElement.sharp(this._getSharpParam(), sharpDirection)
},
customPositionIsAvailable: () => false,
getOrthogonalAxis: _noop,
getCustomPosition: _noop,
getCustomBoundaryPosition: _noop,
resolveOverlappingForCustomPositioning: _noop,
hasNonBoundaryPosition: () => false,
customPositionIsBoundaryOrthogonalAxis: () => false,
getResolvedBoundaryPosition() {
return this.getOptions().position
},
getAxisSharpDirection() {
var position = this.getResolvedBoundaryPosition();
return this.hasNonBoundaryPosition() || position !== BOTTOM && position !== RIGHT ? 1 : -1
},
getSharpDirectionByCoords(coords) {
var canvas = this._getCanvasStartEnd();
var maxCoord = Math.max(canvas.start, canvas.end);
return this.getRadius ? 0 : maxCoord !== coords[this._isHorizontal ? "x" : "y"] ? 1 : -1
},
_getGridLineDrawer: function() {
var that = this;
return function(tick, gridStyle) {
var grid = that._getGridPoints(tick.coords);
if (grid.points) {
return that._createPathElement(grid.points, gridStyle, that.getSharpDirectionByCoords(tick.coords))
}
return null
}
},
_getGridPoints: function(coords) {
var isHorizontal = this._isHorizontal;
var tickPositionField = isHorizontal ? "x" : "y";
var orthogonalPositions = this._orthogonalPositions;
var positionFrom = orthogonalPositions.start;
var positionTo = orthogonalPositions.end;
var borderOptions = this.borderOptions;
var canvasStart = isHorizontal ? LEFT : TOP;
var canvasEnd = isHorizontal ? RIGHT : BOTTOM;
var axisCanvas = this.getCanvas();
var canvas = {
left: axisCanvas.left,
right: axisCanvas.width - axisCanvas.right,
top: axisCanvas.top,
bottom: axisCanvas.height - axisCanvas.bottom
};
var firstBorderLinePosition = borderOptions.visible && borderOptions[canvasStart] ? canvas[canvasStart] : void 0;
var lastBorderLinePosition = borderOptions.visible && borderOptions[canvasEnd] ? canvas[canvasEnd] : void 0;
var minDelta = MAX_GRID_BORDER_ADHENSION + firstBorderLinePosition;
var maxDelta = lastBorderLinePosition - MAX_GRID_BORDER_ADHENSION;
if (this.areCoordsOutsideAxis(coords) || void 0 === coords[tickPositionField] || coords[tickPositionField] < minDelta || coords[tickPositionField] > maxDelta) {
return {
points: null
}
}
return {
points: isHorizontal ? null !== coords[tickPositionField] ? [coords[tickPositionField], positionFrom, coords[tickPositionField], positionTo] : null : null !== coords[tickPositionField] ? [positionFrom, coords[tickPositionField], positionTo, coords[tickPositionField]] : null
}
},
_getConstantLinePos: function(parsedValue, canvasStart, canvasEnd) {
var value = this._getTranslatedCoord(parsedValue);
if (!isDefined(value) || value < _min(canvasStart, canvasEnd) || value > _max(canvasStart, canvasEnd)) {
return
}
return value
},
_getConstantLineGraphicAttributes: function(value) {
var positionFrom = this._orthogonalPositions.start;
var positionTo = this._orthogonalPositions.end;
return {
points: this._isHorizontal ? [value, positionFrom, value, positionTo] : [positionFrom, value, positionTo, value]
}
},
_createConstantLine: function(value, attr) {
return this._createPathElement(this._getConstantLineGraphicAttributes(value).points, attr, getConstantLineSharpDirection(value, this._getCanvasStartEnd()))
},
_drawConstantLineLabelText: function(text, x, y, _ref2, group) {
var {
font: font,
cssClass: cssClass
} = _ref2;
return this._renderer.text(text, x, y).css(patchFontOptions(extend({}, this._options.label.font, font))).attr({
align: "center",
class: cssClass
}).append(group)
},
_drawConstantLineLabels: function(parsedValue, lineLabelOptions, value, group) {
var _text;
var text = lineLabelOptions.text;
var options = this._options;
var labelOptions = options.label;
this._checkAlignmentConstantLineLabels(lineLabelOptions);
text = null !== (_text = text) && void 0 !== _text ? _text : this.formatLabel(parsedValue, labelOptions);
var coords = this._getConstantLineLabelsCoords(value, lineLabelOptions);
return this._drawConstantLineLabelText(text, coords.x, coords.y, lineLabelOptions, group)
},
_getStripPos: function(startValue, endValue, canvasStart, canvasEnd, range) {
var isContinuous = !!(range.minVisible || range.maxVisible);
var categories = (range.categories || []).reduce((function(result, cat) {
result.push(cat.valueOf());
return result
}), []);
var start;
var end;
var swap;
var startCategoryIndex;
var endCategoryIndex;
if (!isContinuous) {
if (isDefined(startValue) && isDefined(endValue)) {
var parsedStartValue = this.parser(startValue);
var parsedEndValue = this.parser(endValue);
startCategoryIndex = inArray(isDefined(parsedStartValue) ? parsedStartValue.valueOf() : void 0, categories);
endCategoryIndex = inArray(isDefined(parsedEndValue) ? parsedEndValue.valueOf() : void 0, categories);
if (-1 === startCategoryIndex || -1 === endCategoryIndex) {
return {
from: 0,
to: 0,
outOfCanvas: true
}
}
if (startCategoryIndex > endCategoryIndex) {
swap = endValue;
endValue = startValue;
startValue = swap
}
}
}
if (isDefined(startValue)) {
startValue = this.validateUnit(startValue, "E2105", "strip");
start = this._getTranslatedCoord(startValue, -1)
} else {
start = canvasStart
}
if (isDefined(endValue)) {
endValue = this.validateUnit(endValue, "E2105", "strip");
end = this._getTranslatedCoord(endValue, 1)
} else {
end = canvasEnd
}
var stripPosition = start < end ? {
from: start,
to: end
} : {
from: end,
to: start
};
var visibleArea = this.getVisibleArea();
if (stripPosition.from <= visibleArea[0] && stripPosition.to <= visibleArea[0] || stripPosition.from >= visibleArea[1] && stripPosition.to >= visibleArea[1]) {
stripPosition.outOfCanvas = true
}
return stripPosition
},
_getStripGraphicAttributes: function(fromPoint, toPoint) {
var x;
var y;
var width;
var height;
var orthogonalPositions = this._orthogonalPositions;
var positionFrom = orthogonalPositions.start;
var positionTo = orthogonalPositions.end;
if (this._isHorizontal) {
x = fromPoint;
y = _min(positionFrom, positionTo);
width = toPoint - fromPoint;
height = _abs(positionFrom - positionTo)
} else {
x = _min(positionFrom, positionTo);
y = fromPoint;
width = _abs(positionFrom - positionTo);
height = _abs(fromPoint - toPoint)
}
return {
x: x,
y: y,
width: width,
height: height
}
},
_createStrip: function(attrs) {
return this._renderer.rect(attrs.x, attrs.y, attrs.width, attrs.height)
},
_adjustStripLabels: function() {
var that = this;
this._strips.forEach((function(strip) {
if (strip.label) {
strip.label.attr(that._getAdjustedStripLabelCoords(strip))
}
}))
},
_adjustLabelsCoord(offset, maxWidth, checkCanvas) {
var getContainerAttrs = tick => this._getLabelAdjustedCoord(tick, offset + (tick.labelOffset || 0), maxWidth, checkCanvas);
this._majorTicks.forEach((function(tick) {
if (tick.label) {
tick.updateMultilineTextAlignment();
tick.label.attr(getContainerAttrs(tick))
} else {
tick.templateContainer && tick.templateContainer.attr(getContainerAttrs(tick))
}
}))
},
_adjustLabels: function(offset) {
var options = this.getOptions();
var positionsAreConsistent = options.position === options.label.position;
var maxSize = this._majorTicks.reduce((function(size, tick) {
if (!tick.getContentContainer()) {
return size
}
var bBox = tick.labelRotationAngle ? rotateBBox(tick.labelBBox, [tick.labelCoords.x, tick.labelCoords.y], -tick.labelRotationAngle) : tick.labelBBox;
return {
width: _max(size.width || 0, bBox.width),
height: _max(size.height || 0, bBox.height),
offset: _max(size.offset || 0, tick.labelOffset || 0)
}
}), {});
var additionalOffset = positionsAreConsistent ? this._isHorizontal ? maxSize.height : maxSize.width : 0;
this._adjustLabelsCoord(offset, maxSize.width);
return offset + additionalOffset + (additionalOffset && this._options.label.indentFromAxis) + (positionsAreConsistent ? maxSize.offset : 0)
},
_getLabelAdjustedCoord: function(tick, offset, maxWidth) {
offset = offset || 0;
var options = this._options;
var templateBox = tick.templateContainer && tick.templateContainer.getBBox();
var box = templateBox || rotateBBox(tick.labelBBox, [tick.labelCoords.x, tick.labelCoords.y], -tick.labelRotationAngle || 0);
var textAlign = tick.labelAlignment || options.label.alignment;
var isDiscrete = "discrete" === this._options.type;
var isFlatLabel = tick.labelRotationAngle % 90 === 0;
var indentFromAxis = options.label.indentFromAxis;
var labelPosition = options.label.position;
var axisPosition = this._axisPosition;
var labelCoords = tick.labelCoords;
var labelX = labelCoords.x;
var translateX;
var translateY;
if (this._isHorizontal) {
if (labelPosition === BOTTOM) {
translateY = axisPosition + indentFromAxis - box.y + offset
} else {
translateY = axisPosition - indentFromAxis - (box.y + box.height) - offset
}
if (textAlign === RIGHT) {
translateX = isDiscrete && isFlatLabel ? tick.coords.x - (box.x + box.width) : labelX - box.x - box.width
} else if (textAlign === LEFT) {
translateX = isDiscrete && isFlatLabel ? labelX - box.x - (tick.coords.x - labelX) : labelX - box.x
} else {
translateX = labelX - box.x - box.width / 2
}
} else {
translateY = labelCoords.y - box.y - box.height / 2;
if (labelPosition === LEFT) {
if (textAlign === LEFT) {
translateX = axisPosition - indentFromAxis - maxWidth - box.x
} else if (textAlign === CENTER) {
translateX = axisPosition - indentFromAxis - maxWidth / 2 - box.x - box.width / 2
} else {
translateX = axisPosition - indentFromAxis - box.x - box.width
}
translateX -= offset
} else {
if (textAlign === RIGHT) {
translateX = axisPosition + indentFromAxis + maxWidth - box.x - box.width
} else if (textAlign === CENTER) {
translateX = axisPosition + indentFromAxis + maxWidth / 2 - box.x - box.width / 2
} else {
translateX = axisPosition + indentFromAxis - box.x
}
translateX += offset
}
}
return {
translateX: translateX,
translateY: translateY
}
},
_createAxisConstantLineGroups: function() {
var renderer = this._renderer;
var classSelector = this._axisCssPrefix;
var constantLinesClass = classSelector + "constant-lines";
var insideGroup = renderer.g().attr({
class: constantLinesClass
});
var outsideGroup1 = renderer.g().attr({
class: constantLinesClass
});
var outsideGroup2 = renderer.g().attr({
class: constantLinesClass
});
return {
inside: insideGroup,
outside1: outsideGroup1,
left: outsideGroup1,
top: outsideGroup1,
outside2: outsideGroup2,
right: outsideGroup2,
bottom: outsideGroup2,
remove: function() {
this.inside.remove();
this.outside1.remove();
this.outside2.remove()
},
clear: function() {
this.inside.clear();
this.outside1.clear();
this.outside2.clear()
}
}
},
_createAxisGroups: function() {
var renderer = this._renderer;
var classSelector = this._axisCssPrefix;
this._axisGroup = renderer.g().attr({
class: classSelector + "axis"
}).enableLinks();
this._axisStripGroup = renderer.g().attr({
class: classSelector + "strips"
});
this._axisGridGroup = renderer.g().attr({
class: classSelector + "grid"
});
this._axisElementsGroup = renderer.g().attr({
class: classSelector + "elements"
});
this._axisLineGroup = renderer.g().attr({
class: classSelector + "line"
}).linkOn(this._axisGroup, "axisLine").linkAppend();
this._axisTitleGroup = renderer.g().attr({
class: classSelector + "title"
}).append(this._axisGroup);
this._axisConstantLineGroups = {
above: this._createAxisConstantLineGroups(),
under: this._createAxisConstantLineGroups()
};
this._axisStripLabelGroup = renderer.g().attr({
class: classSelector + "axis-labels"
})
},
_clearAxisGroups: function() {
this._axisGroup.remove();
this._axisStripGroup.remove();
this._axisStripLabelGroup.remove();
this._axisConstantLineGroups.above.remove();
this._axisConstantLineGroups.under.remove();
this._axisGridGroup.remove();
this._axisTitleGroup.clear();
if (!this._options.label.template || !this.isRendered()) {
this._axisElementsGroup.remove();
this._axisElementsGroup.clear()
}
this._axisLineGroup && this._axisLineGroup.clear();
this._axisStripGroup && this._axisStripGroup.clear();
this._axisGridGroup && this._axisGridGroup.clear();
this._axisConstantLineGroups.above.clear();
this._axisConstantLineGroups.under.clear();
this._axisStripLabelGroup && this._axisStripLabelGroup.clear()
},
_getLabelFormatObject: function(value, labelOptions, range, point, tickInterval, ticks) {
range = range || this._getViewportRange();
var formatObject = {
value: value,
valueText: _format(value, {
labelOptions: labelOptions,
ticks: ticks || convertTicksToValues(this._majorTicks),
tickInterval: null !== tickInterval && void 0 !== tickInterval ? tickInterval : this._tickInterval,
dataType: this._options.dataType,
logarithmBase: this._options.logarithmBase,
type: this._options.type,
showTransition: !this._options.marker.visible,
point: point
}) || "",
min: range.minVisible,
max: range.maxVisible
};
if (point) {
formatObject.point = point
}
return formatObject
},
formatLabel: function(value, labelOptions, range, point, tickInterval, ticks) {
var formatObject = this._getLabelFormatObject(value, labelOptions, range, point, tickInterval, ticks);
return isFunction(labelOptions.customizeText) ? labelOptions.customizeText.call(formatObject, formatObject) : formatObject.valueText
},
formatHint: function(value, labelOptions, range) {
var formatObject = this._getLabelFormatObject(value, labelOptions, range);
return isFunction(labelOptions.customizeHint) ? labelOptions.customizeHint.call(formatObject, formatObject) : void 0
},
formatRange(startValue, endValue, interval) {
return formatRange(startValue, endValue, interval, this.getOptions())
},
_setTickOffset: function() {
var options = this._options;
var discreteAxisDivisionMode = options.discreteAxisDivisionMode;
this._tickOffset = +("crossLabels" !== discreteAxisDivisionMode || !discreteAxisDivisionMode)
},
resetApplyingAnimation: function(isFirstDrawing) {
this._resetApplyingAnimation = true;
if (isFirstDrawing) {
this._firstDrawing = true
}
},
isFirstDrawing() {
return this._firstDrawing
},
getMargins: function() {
var that = this;
var {
position: position,
offset: offset,
customPosition: customPosition,
placeholderSize: placeholderSize,
grid: grid,
tick: tick,
crosshairMargin: crosshairMargin
} = that._options;
var isDefinedCustomPositionOption = isDefined(customPosition);
var boundaryPosition = that.getResolvedBoundaryPosition();
var canvas = that.getCanvas();
var cLeft = canvas.left;
var cTop = canvas.top;
var cRight = canvas.width - canvas.right;
var cBottom = canvas.height - canvas.bottom;
var edgeMarginCorrection = _max(grid.visible && grid.width || 0, tick.visible && tick.width || 0);
var constantLineAboveSeries = that._axisConstantLineGroups.above;
var constantLineUnderSeries = that._axisConstantLineGroups.under;
var boxes = [that._axisElementsGroup, constantLineAboveSeries.outside1, constantLineAboveSeries.outside2, constantLineUnderSeries.outside1, constantLineUnderSeries.outside2, that._axisLineGroup].map(group => group && group.getBBox()).concat(function(group) {
var box = group && group.getBBox();
if (!box || box.isEmpty) {
return box
}
if (that._isHorizontal) {
box.x = cLeft;
box.width = cRight - cLeft
} else {
box.y = cTop;
box.height = cBottom - cTop
}
return box
}(that._axisTitleGroup));
var margins = calculateCanvasMargins(boxes, canvas);
margins[position] += crosshairMargin;
if (that.hasNonBoundaryPosition() && isDefinedCustomPositionOption) {
margins[boundaryPosition] = 0
}
if (placeholderSize) {
margins[position] = placeholderSize
}
if (edgeMarginCorrection) {
if (that._isHorizontal && canvas.right < edgeMarginCorrection && margins.right < edgeMarginCorrection) {
margins.right = edgeMarginCorrection
}
if (!that._isHorizontal && canvas.bottom < edgeMarginCorrection && margins.bottom < edgeMarginCorrection) {
margins.bottom = edgeMarginCorrection
}
}
if (!isDefinedCustomPositionOption && isDefined(offset)) {
var moveByOffset = that.customPositionIsBoundary() && (offset > 0 && (boundaryPosition === LEFT || boundaryPosition === TOP) || offset < 0 && (boundaryPosition === RIGHT || boundaryPosition === BOTTOM));
margins[boundaryPosition] -= moveByOffset ? offset : 0
}
return margins
},
validateUnit: function(unit, idError, parameters) {
unit = this.parser(unit);
if (void 0 === unit && idError) {
this._incidentOccurred(idError, [parameters])
}
return unit
},
_setType: function(axisType, drawingType) {
var axisTypeMethods;
switch (axisType) {
case "xyAxes":
axisTypeMethods = xyMethods;
break;
case "polarAxes":
axisTypeMethods = polarMethods
}
extend(this, axisTypeMethods[drawingType])
},
_getSharpParam: function() {
return true
},
_disposeBreaksGroup: _noop,
dispose: function() {
[this._axisElementsGroup, this._axisStripGroup, this._axisGroup].forEach((function(g) {
g.dispose()
}));
this._strips = this._title = null;
this._axisStripGroup = this._axisConstantLineGroups = this._axisStripLabelGroup = this._axisBreaksGroup = null;
this._axisLineGroup = this._axisElementsGroup = this._axisGridGroup = null;
this._axisGroup = this._axisTitleGroup = null;
this._axesContainerGroup = this._stripsGroup = this._constantLinesGroup = this._labelsAxesGroup = null;
this._renderer = this._options = this._textOptions = this._textFontStyles = null;
this._translator = null;
this._majorTicks = this._minorTicks = null;
this._disposeBreaksGroup();
this._templatesRendered && this._templatesRendered.reject()
},
getOptions: function() {
return this._options
},
setPane: function(pane) {
this.pane = pane;
this._options.pane = pane
},
setTypes: function(type, axisType, typeSelector) {
this._options.type = type || this._options.type;
this._options[typeSelector] = axisType || this._options[typeSelector];
this._updateTranslator()
},
resetTypes: function(typeSelector) {
this._options.type = this._initTypes.type;
this._options[typeSelector] = this._initTypes[typeSelector]
},
getTranslator: function() {
return this._translator
},
updateOptions: function(options) {
var that = this;
var labelOpt = options.label;
validateAxisOptions(options);
that._options = options;
options.tick = options.tick || {};
options.minorTick = options.minorTick || {};
options.grid = options.grid || {};
options.minorGrid = options.minorGrid || {};
options.title = options.title || {};
options.marker = options.marker || {};
that._initTypes = {
type: options.type,
argumentType: options.argumentType,
valueType: options.valueType
};
that._setTickOffset();
that._isHorizontal = options.isHorizontal;
that.pane = options.pane;
that.name = options.name;
that.priority = options.priority;
that._hasLabelFormat = "" !== labelOpt.format && isDefined(labelOpt.format);
that._textOptions = {
opacity: labelOpt.opacity,
align: "center",
class: labelOpt.cssClass
};
that._textFontStyles = patchFontOptions(labelOpt.font);
if (options.type === constants.logarithmic) {
if (options.logarithmBaseError) {
that._incidentOccurred("E2104");
delete options.logarithmBaseError
}
}
that._updateTranslator();
that._createConstantLines();
that._strips = (options.strips || []).map(o => createStrip(that, o));
that._majorTicks = that._minorTicks = null;
that._firstDrawing = true
},
calculateInterval: function(value, prevValue) {
var options = this._options;
if (!options || options.type !== constants.logarithmic) {
return _abs(value - prevValue)
}
var {
allowNegatives: allowNegatives,
linearThreshold: linearThreshold
} = new Range(this.getTranslator().getBusinessRange());
return _abs(getLog(value, options.logarithmBase, allowNegatives, linearThreshold) - getLog(prevValue, options.logarithmBase, allowNegatives, linearThreshold))
},
getCanvasRange() {
var translator = this._translator;
return {
startValue: translator.from(translator.translate("canvas_position_start")),
endValue: translator.from(translator.translate("canvas_position_end"))
}
},
_processCanvas: function(canvas) {
return canvas
},
updateCanvas: function(canvas, canvasRedesign) {
if (!canvasRedesign) {
var positions = this._orthogonalPositions = {
start: !this._isHorizontal ? canvas.left : canvas.top,
end: !this._isHorizontal ? canvas.width - canvas.right : canvas.height - canvas.bottom
};
positions.center = positions.start + (positions.end - positions.start) / 2
} else {
this._orthogonalPositions = null
}
this._canvas = canvas;
this._translator.updateCanvas(this._processCanvas(canvas));
this._initAxisPositions()
},
getCanvas: function() {
return this._canvas
},
getAxisShift() {
return this._axisShift || 0
},
hideTitle: function() {
if (this._options.title.text) {
this._incidentOccurred("W2105", [this._isHorizontal ? "horizontal" : "vertical"]);
this._axisTitleGroup.clear()
}
},
getTitle: function() {
return this._title
},
hideOuterElements: function() {
var options = this._options;
if ((options.label.visible || this._outsideConstantLines.length) && !this._translator.getBusinessRange().isEmpty()) {
this._incidentOccurred("W2106", [this._isHorizontal ? "horizontal" : "vertical"]);
this._axisElementsGroup.clear();
callAction(this._outsideConstantLines, "removeLabel")
}
},
_resolveLogarithmicOptionsForRange(range) {
var options = this._options;
if (options.type === constants.logarithmic) {
range.addRange({
allowNegatives: void 0 !== options.allowNegatives ? options.allowNegatives : range.min <= 0
});
if (!isNaN(options.linearThreshold)) {
range.linearThreshold = options.linearThreshold
}
}
},
adjustViewport(businessRange) {
var options = this._options;
var isDiscrete = options.type === constants.discrete;
var categories = this._seriesData && this._seriesData.categories || [];
var wholeRange = this.adjustRange(getVizRangeObject(options.wholeRange));
var visualRange = this.getViewport() || {};
var result = new Range(businessRange);
this._addConstantLinesToRange(result, "minVisible", "maxVisible");
var minDefined = isDefined(visualRange.startValue);
var maxDefined = isDefined(visualRange.endValue);
if (!isDiscrete) {
minDefined = minDefined && (!isDefined(wholeRange.endValue) || visualRange.startValue < wholeRange.endValue);
maxDefined = maxDefined && (!isDefined(wholeRange.startValue) || visualRange.endValue > wholeRange.startValue)
}
var minVisible = minDefined ? visualRange.startValue : result.minVisible;
var maxVisible = maxDefined ? visualRange.endValue : result.maxVisible;
if (!isDiscrete) {
var _wholeRange$startValu, _wholeRange$endValue;
result.min = null !== (_wholeRange$startValu = wholeRange.startValue) && void 0 !== _wholeRange$startValu ? _wholeRange$startValu : result.min;
result.max = null !== (_wholeRange$endValue = wholeRange.endValue) && void 0 !== _wholeRange$endValue ? _wholeRange$endValue : result.max
} else {
var categoriesInfo = getCategoriesInfo(categories, wholeRange.startValue, wholeRange.endValue);
categories = categoriesInfo.categories;
result.categories = categories
}
var adjustedVisualRange = adjustVisualRange({
axisType: options.type,
dataType: options.dataType,
base: options.logarithmBase
}, {
startValue: minDefined ? visualRange.startValue : void 0,
endValue: maxDefined ? visualRange.endValue : void 0,
length: visualRange.length
}, {
categories: categories,
min: wholeRange.startValue,
max: wholeRange.endValue
}, {
categories: categories,
min: minVisible,
max: maxVisible
});
result.minVisible = adjustedVisualRange.startValue;
result.maxVisible = adjustedVisualRange.endValue;
!isDefined(result.min) && (result.min = result.minVisible);
!isDefined(result.max) && (result.max = result.maxVisible);
result.addRange({});
this._resolveLogarithmicOptionsForRange(result);
return result
},
adjustRange(range) {
range = range || {};
var isDiscrete = this._options.type === constants.discrete;
var isLogarithmic = this._options.type === constants.logarithmic;
var disabledNegatives = false === this._options.allowNegatives;
if (isLogarithmic) {
range.startValue = disabledNegatives && range.startValue <= 0 ? null : range.startValue;
range.endValue = disabledNegatives && range.endValue <= 0 ? null : range.endValue
}
if (!isDiscrete && isDefined(range.startValue) && isDefined(range.endValue) && range.startValue > range.endValue) {
var tmp = range.endValue;
range.endValue = range.startValue;
range.startValue = tmp
}
return range
},
_getVisualRangeUpdateMode(viewport, newRange, oppositeValue) {
var value = this._options.visualRangeUpdateMode;
var translator = this._translator;
var range = this._seriesData;
if (this.isArgumentAxis) {
if (-1 === [SHIFT, KEEP, RESET].indexOf(value)) {
if (range.axisType === constants.discrete) {
var categories = range.categories;
var newCategories = newRange.categories;
var visualRange = this.visualRange();
if (categories && newCategories && categories.length && -1 !== newCategories.map(c => c.valueOf()).join(",").indexOf(categories.map(c => c.valueOf()).join(",")) && (visualRange.startValue.valueOf() !== categories[0].valueOf() || visualRange.endValue.valueOf() !== categories[categories.length - 1].valueOf())) {
value = KEEP
} else {
value = RESET
}
} else {
var minPoint = translator.translate(range.min);
var minVisiblePoint = translator.translate(viewport.startValue);
var maxPoint = translator.translate(range.max);
var maxVisiblePoint = translator.translate(viewport.endValue);
if (minPoint === minVisiblePoint && maxPoint === maxVisiblePoint) {
value = RESET
} else if (minPoint !== minVisiblePoint && maxPoint === maxVisiblePoint) {
value = SHIFT
} else {
value = KEEP
}
}
}
} else if (-1 === [KEEP, RESET].indexOf(value)) {
if (oppositeValue === KEEP) {
value = KEEP
} else {
value = RESET
}
}
return value
},
_handleBusinessRangeChanged(oppositeVisualRangeUpdateMode, axisReinitialized, newRange) {
var visualRange = this.visualRange();
if (axisReinitialized || this._translator.getBusinessRange().isEmpty()) {
return
}
var visualRangeUpdateMode = this._lastVisualRangeUpdateMode = this._getVisualRangeUpdateMode(visualRange, newRange, oppositeVisualRangeUpdateMode);
if (!this.isArgumentAxis) {
var viewport = this.getViewport();
if (!isDefined(viewport.startValue) && !isDefined(viewport.endValue) && !isDefined(viewport.length)) {
visualRangeUpdateMode = RESET
}
}
this._prevDataWasEmpty && (visualRangeUpdateMode = KEEP);
if (visualRangeUpdateMode === KEEP) {
this._setVisualRange([visualRange.startValue, visualRange.endValue])
}
if (visualRangeUpdateMode === RESET) {
this._setVisualRange([null, null])
}
if (visualRangeUpdateMode === SHIFT) {
this._setVisualRange({
length: this.getVisualRangeLength()
})
}
},
getVisualRangeLength(range) {
var currentBusinessRange = range || this._translator.getBusinessRange();
var {
type: type
} = this._options;
var length;
if (type === constants.logarithmic) {
length = adjust(this.calculateInterval(currentBusinessRange.maxVisible, currentBusinessRange.minVisible))
} else if (type === constants.discrete) {
var categoriesInfo = getCategoriesInfo(currentBusinessRange.categories, currentBusinessRange.minVisible, currentBusinessRange.maxVisible);
length = categoriesInfo.categories.length
} else {
length = currentBusinessRange.maxVisible - currentBusinessRange.minVisible
}
return length
},
getVisualRangeCenter(range, useMerge) {
var translator = this.getTranslator();
var businessRange = translator.getBusinessRange();
var currentBusinessRange = useMerge ? extend(true, {}, businessRange, range || {}) : range || businessRange;
var {
type: type,
logarithmBase: logarithmBase
} = this._options;
var center;
if (!isDefined(currentBusinessRange.minVisible) || !isDefined(currentBusinessRange.maxVisible)) {
return
}
if (type === constants.logarithmic) {
var {
allowNegatives: allowNegatives,
linearThreshold: linearThreshold,
minVisible: minVisible,
maxVisible: maxVisible
} = currentBusinessRange;
center = raiseTo(adjust(getLog(maxVisible, logarithmBase, allowNegatives, linearThreshold) + getLog(minVisible, logarithmBase, allowNegatives, linearThreshold)) / 2, logarithmBase, allowNegatives, linearThreshold)
} else if (type === constants.discrete) {
var categoriesInfo = getCategoriesInfo(currentBusinessRange.categories, currentBusinessRange.minVisible, currentBusinessRange.maxVisible);
var index = Math.ceil(categoriesInfo.categories.length / 2) - 1;
center = businessRange.categories.indexOf(categoriesInfo.categories[index])
} else {
center = translator.toValue((currentBusinessRange.maxVisible.valueOf() + currentBusinessRange.minVisible.valueOf()) / 2)
}
return center
},
setBusinessRange(range, axisReinitialized, oppositeVisualRangeUpdateMode, argCategories) {
var _that$_seriesData$min, _that$_seriesData$max;
var options = this._options;
var isDiscrete = options.type === constants.discrete;
this._handleBusinessRangeChanged(oppositeVisualRangeUpdateMode, axisReinitialized, range);
this._seriesData = new Range(range);
var dataIsEmpty = this._seriesData.isEmpty();
this._prevDataWasEmpty = dataIsEmpty;
this._seriesData.addRange({
categories: options.categories,
dataType: options.dataType,
axisType: options.type,
base: options.logarithmBase,
invert: options.inverted
});
this._resolveLogarithmicOptionsForRange(this._seriesData);
if (!isDiscrete) {
if (!isDefined(this._seriesData.min) && !isDefined(this._seriesData.max)) {
var visualRange = this.getViewport();
visualRange && this._seriesData.addRange({
min: visualRange.startValue,
max: visualRange.endValue
})
}
var synchronizedValue = options.synchronizedValue;
if (isDefined(synchronizedValue)) {
this._seriesData.addRange({
min: synchronizedValue,
max: synchronizedValue
})
}
}
this._seriesData.minVisible = null !== (_that$_seriesData$min = this._seriesData.minVisible) && void 0 !== _that$_seriesData$min ? _that$_seriesData$min : this._seriesData.min;
this._seriesData.maxVisible = null !== (_that$_seriesData$max = this._seriesData.maxVisible) && void 0 !== _that$_seriesData$max ? _that$_seriesData$max : this._seriesData.max;
if (!this.isArgumentAxis && options.showZero) {
this._seriesData.correctValueZeroLevel()
}
this._seriesData.sortCategories(this.getCategoriesSorter(argCategories));
this._seriesData.userBreaks = this._seriesData.isEmpty() ? [] : this._getScaleBreaks(options, this._seriesData, this._series, this.isArgumentAxis);
this._translator.updateBusinessRange(this._getViewportRange())
},
_addConstantLinesToRange(dataRange, minValueField, maxValueField) {
this._out