highcharts
Version:
JavaScript charting framework
1,747 lines (1,605 loc) • 1.73 MB
JavaScript
/**
* @license Highstock JS v6.2.0 (2018-10-17)
*
* (c) 2009-2016 Torstein Honsi
*
* License: www.highcharts.com/license
*/
'use strict';
(function (root, factory) {
if (typeof module === 'object' && module.exports) {
module.exports = root.document ?
factory(root) :
factory;
} else if (typeof define === 'function' && define.amd) {
define(function () {
return factory(root);
});
} else {
root.Highcharts = factory(root);
}
}(typeof window !== 'undefined' ? window : this, function (win) {
var Highcharts = (function () {
/**
* (c) 2010-2018 Torstein Honsi
*
* License: www.highcharts.com/license
*/
/* global win, window */
// glob is a temporary fix to allow our es-modules to work.
var glob = typeof win === 'undefined' ? window : win,
doc = glob.document,
SVG_NS = 'http://www.w3.org/2000/svg',
userAgent = (glob.navigator && glob.navigator.userAgent) || '',
svg = (
doc &&
doc.createElementNS &&
!!doc.createElementNS(SVG_NS, 'svg').createSVGRect
),
isMS = /(edge|msie|trident)/i.test(userAgent) && !glob.opera,
isFirefox = userAgent.indexOf('Firefox') !== -1,
isChrome = userAgent.indexOf('Chrome') !== -1,
hasBidiBug = (
isFirefox &&
parseInt(userAgent.split('Firefox/')[1], 10) < 4 // issue #38
);
var Highcharts = glob.Highcharts ? glob.Highcharts.error(16, true) : {
product: 'Highstock',
version: '6.2.0',
deg2rad: Math.PI * 2 / 360,
doc: doc,
hasBidiBug: hasBidiBug,
hasTouch: doc && doc.documentElement.ontouchstart !== undefined,
isMS: isMS,
isWebKit: userAgent.indexOf('AppleWebKit') !== -1,
isFirefox: isFirefox,
isChrome: isChrome,
isSafari: !isChrome && userAgent.indexOf('Safari') !== -1,
isTouchDevice: /(Mobile|Android|Windows Phone)/.test(userAgent),
SVG_NS: SVG_NS,
chartCount: 0,
seriesTypes: {},
symbolSizes: {},
svg: svg,
win: glob,
marginNames: ['plotTop', 'marginRight', 'marginBottom', 'plotLeft'],
noop: function () {
return undefined;
},
/**
* An array containing the current chart objects in the page. A chart's
* position in the array is preserved throughout the page's lifetime. When
* a chart is destroyed, the array item becomes `undefined`.
*
* @name Highcharts.charts
* @type {Array<Highcharts.Chart>}
*/
charts: []
};
return Highcharts;
}());
(function (H) {
/**
* (c) 2010-2018 Torstein Honsi
*
* License: www.highcharts.com/license
*/
/**
* Reference to the global SVGElement class as a workaround for a name conflict
* in the Highcharts namespace.
*
* @typedef {global.SVGElement} GlobalSVGElement
*
* @see https://developer.mozilla.org/en-US/docs/Web/API/SVGElement
*/
/**
* An animation configuration. Animation configurations can also be defined as
* booleans, where `false` turns off animation and `true` defaults to a duration
* of 500ms.
*
* @typedef Highcharts.AnimationOptionsObject
*
* @property {number} duration
* The animation duration in milliseconds.
*
* @property {string} [easing]
* The name of an easing function as defined on the `Math` object.
*
* @property {Function} [complete]
* A callback function to exectute when the animation finishes.
*
* @property {Function} [step]
* A callback function to execute on each step of each attribute or
* CSS property that's being animated. The first argument contains
* information about the animation and progress.
*/
/**
* A style object with camel case property names to define visual appearance of
* a SVG element or HTML element. The properties can be whatever styles are
* supported on the given SVG or HTML element.
*
* @example
* {
* fontFamily: 'monospace',
* fontSize: '1.2em'
* }
*
* @typedef Highcharts.CSSObject
*
* @property {boolean|number|string|undefined} [key:string]
*
* @property {string} [background]
* Background style for the element.
*
* @property {Highcharts.ColorString} [backgroundColor]
* Background color of the element.
*
* @property {string} [border]
* Border style for the element.
*
* @property {number} [borderRadius]
* Radius of the element border.
*
* @property {"contrast"|Highcharts.ColorString} [color]
* Color used in the element. The "contrast" option is a Highcharts
* custom property that results in black or white, depending on the
* background of the element.
*
* @property {string} [cursor]
* Style of the mouse cursor when resting over the element.
*
* @property {string} [fontFamily]
* Font family of the element text. Multiple values have to be in
* decreasing preference order and separated by comma.
*
* @property {string} [fontSize]
* Font size of the element text.
*
* @property {string} [fontWeight]
* Font weight of the element text.
*
* @property {number} [height]
* Height of the element.
*
* @property {number} [lineWidth]
* Width of the element border.
*
* @property {number} [opacity]
* Opacity of the element.
*
* @property {string} [padding]
* Space around the element content.
*
* @property {string} [pointerEvents]
* Behaviour of the element when the mouse cursor rests over it.
*
* @property {string} [position]
* Positioning of the element.
*
* @property {string} [textAlign]
* Alignment of the element text.
*
* @property {string} [textOutline]
* Outline style of the element text.
*
* @property {string} [textDecoration]
* Additional decoration of the element text.
*
* @property {string} [textOverflow]
* Line break style of the element text. Highcharts SVG elements
* support `ellipsis` when a `width` is set.
*
* @property {string} [transition]
* Animated transition of selected element properties.
*
* @property {string} [top]
* Top spacing of the element relative to the parent element.
*
* @property {string} [whiteSpace]
* Line break style of the element text.
*
* @property {number} [width]
* Width of the element.
*/
/**
* Generic dictionary in TypeScript notation.
*
* @typedef Highcharts.Dictionary<T>
*
* @property {T} [key:string]
*/
/**
* An object of key-value pairs for HTML attributes.
*
* @typedef {Highcharts.Dictionary<boolean|number|string>} Highcharts.HTMLAttributes
*/
/**
* The iterator callback.
*
* @callback Highcharts.EachCallbackFunction<T>
*
* @param {T} item
* The array item.
*
* @param {number} index
* The item's index in the array.
*
* @param {Array<T>} arr
* The array that each is being applied to.
*/
/**
* The function callback to execute when the event is fired. The `this` context
* contains the instance, that fired the event.
*
* @callback Highcharts.EventCallbackFunction
*
* @param {Highcharts.Dictionary<*>} [eventArguments]
* Event arguments.
*/
/**
* Formats data as a string. Usually the data is accessible throught the `this`
* keyword.
*
* @callback Highcharts.FormatterCallbackFunction
*
* @return {string}
*/
/**
* An HTML DOM element. The type is a reference to the regular SVGElement in the
* global scope.
*
* @typedef {global.HTMLElement} Highcharts.HTMLDOMElement
*
* @see https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement
*/
/**
* The iterator callback.
*
* @callback Highcharts.ObjectEachCallbackFunction
*
* @param {*} value
* The property value.
*
* @param {string} key
* The property key.
*
* @param {*} obj
* The object that objectEach is being applied to.
*/
/**
* An object containing `left` and `top` properties for the position in the
* page.
*
* @typedef Highcharts.OffsetObject
*
* @property {number} left
* Left distance to the page border.
*
* @property {number} top
* Top distance to the page border.
*/
/**
* An object containing `x` and `y` properties for the position of an element.
*
* @typedef Highcharts.PositionObject
*
* @property {number} x
* X position of the element.
*
* @property {number} y
* Y position of the element.
*/
/**
* If a number is given, it defines the pixel length. If a percentage string is
* given, like for example `'50%'`, the setting defines a length relative to a
* base size, for example the size of a container.
*
* @typedef {number|string} Highcharts.RelativeSize
*/
/**
* An object of key-value pairs for SVG attributes. Attributes in Highcharts
* elements for the most parts correspond to SVG, but some are specific to
* Highcharts, like `zIndex`, `rotation`, `rotationOriginX`,
* `rotationOriginY`, `translateX`, `translateY`, `scaleX` and `scaleY`. SVG
* attributes containing a hyphen are _not_ camel-cased, they should be
* quoted to preserve the hyphen.
*
* @example
* {
* 'stroke': '#ff0000', // basic
* 'stroke-width': 2, // hyphenated
* 'rotation': 45 // custom
* 'd': ['M', 10, 10, 'L', 30, 30, 'z'] // path definition, note format
* }
*
* @typedef Highcharts.SVGAttributes
*
* @property {boolean|number|string|Array<any>|undefined} [key:string]
*
* @property {string|Highcharts.SVGPathArray} [d]
*
* @property {boolean} [inverted]
*
* @property {Array<number>} [matrix]
*
* @property {Highcharts.ColorString} [stroke]
*
* @property {string} [rotation]
*
* @property {number} [rotationOriginX]
*
* @property {number} [rotationOriginY]
*
* @property {number} [scaleX]
*
* @property {number} [scaleY]
*
* @property {number} [translateX]
*
* @property {number} [translateY]
*
* @property {number} [zIndex]
*/
/**
* An SVG DOM element. The type is a reference to the regular SVGElement in the
* global scope.
*
* @typedef {global.GlobalSVGElement} Highcharts.SVGDOMElement
*
* @see https://developer.mozilla.org/en-US/docs/Web/API/SVGElement
*/
/**
* Array of path commands, that will go into the `d` attribute of an SVG
* element.
*
* @typedef {Array<number|Highcharts.SVGPathCommand>} Highcharts.SVGPathArray
*/
/**
* Possible path commands in a SVG path array.
*
* @typedef {string} Highcharts.SVGPathCommand
* @validvalue ["a","c","h","l","m","q","s","t","v","z","A","C","H","L","M","Q","S","T","V","Z"]
*/
/**
* The Highcharts object is the placeholder for all other members, and various
* utility functions. The most important member of the namespace would be the
* chart constructor.
*
* @example
* var chart = Highcharts.chart('container', { ... });
*
* @namespace Highcharts
*/
H.timers = [];
var charts = H.charts,
doc = H.doc,
win = H.win;
/**
* Provide error messages for debugging, with links to online explanation. This
* function can be overridden to provide custom error handling.
*
* @sample highcharts/chart/highcharts-error/
* Custom error handler
*
* @function Highcharts.error
*
* @param {number|string} code
* The error code. See
* [errors.xml]{@link https://github.com/highcharts/highcharts/blob/master/errors/errors.xml}
* for available codes. If it is a string, the error message is printed
* directly in the console.
*
* @param {boolean} [stop=false]
* Whether to throw an error or just log a warning in the console.
*/
H.error = function (code, stop) {
var msg = H.isNumber(code) ?
'Highcharts error #' + code + ': www.highcharts.com/errors/' + code :
code;
if (stop) {
throw new Error(msg);
}
// else ...
if (win.console) {
console.log(msg); // eslint-disable-line no-console
}
};
/**
* An animator object used internally. One instance applies to one property
* (attribute or style prop) on one element. Animation is always initiated
* through {@link SVGElement#animate}.
*
* @example
* var rect = renderer.rect(0, 0, 10, 10).add();
* rect.animate({ width: 100 });
*
* @private
* @class Highcharts.Fx
*
* @param {Highcharts.HTMLDOMElement|Highcharts.SVGElement} elem
* The element to animate.
*
* @param {Highcharts.AnimationOptionsObject} options
* Animation options.
*
* @param {string} prop
* The single attribute or CSS property to animate.
*/
H.Fx = function (elem, options, prop) {
this.options = options;
this.elem = elem;
this.prop = prop;
};
H.Fx.prototype = {
/**
* Set the current step of a path definition on SVGElement.
*
* @function Highcharts.Fx#dSetter
*/
dSetter: function () {
var start = this.paths[0],
end = this.paths[1],
ret = [],
now = this.now,
i = start.length,
startVal;
// Land on the final path without adjustment points appended in the ends
if (now === 1) {
ret = this.toD;
} else if (i === end.length && now < 1) {
while (i--) {
startVal = parseFloat(start[i]);
ret[i] =
isNaN(startVal) ? // a letter instruction like M or L
end[i] :
now * (parseFloat(end[i] - startVal)) + startVal;
}
// If animation is finished or length not matching, land on right value
} else {
ret = end;
}
this.elem.attr('d', ret, null, true);
},
/**
* Update the element with the current animation step.
*
* @function Highcharts.Fx#update
*/
update: function () {
var elem = this.elem,
prop = this.prop, // if destroyed, it is null
now = this.now,
step = this.options.step;
// Animation setter defined from outside
if (this[prop + 'Setter']) {
this[prop + 'Setter']();
// Other animations on SVGElement
} else if (elem.attr) {
if (elem.element) {
elem.attr(prop, now, null, true);
}
// HTML styles, raw HTML content like container size
} else {
elem.style[prop] = now + this.unit;
}
if (step) {
step.call(elem, now, this);
}
},
/**
* Run an animation.
*
* @function Highcharts.Fx#run
*
* @param {number} from
* The current value, value to start from.
*
* @param {number} to
* The end value, value to land on.
*
* @param {string} [unit]
* The property unit, for example `px`.
*/
run: function (from, to, unit) {
var self = this,
options = self.options,
timer = function (gotoEnd) {
return timer.stopped ? false : self.step(gotoEnd);
},
requestAnimationFrame =
win.requestAnimationFrame ||
function (step) {
setTimeout(step, 13);
},
step = function () {
for (var i = 0; i < H.timers.length; i++) {
if (!H.timers[i]()) {
H.timers.splice(i--, 1);
}
}
if (H.timers.length) {
requestAnimationFrame(step);
}
};
if (from === to && !this.elem['forceAnimate:' + this.prop]) {
delete options.curAnim[this.prop];
if (options.complete && H.keys(options.curAnim).length === 0) {
options.complete.call(this.elem);
}
} else { // #7166
this.startTime = +new Date();
this.start = from;
this.end = to;
this.unit = unit;
this.now = this.start;
this.pos = 0;
timer.elem = this.elem;
timer.prop = this.prop;
if (timer() && H.timers.push(timer) === 1) {
requestAnimationFrame(step);
}
}
},
/**
* Run a single step in the animation.
*
* @function Highcharts.Fx#step
*
* @param {boolean} [gotoEnd]
* Whether to go to the endpoint of the animation after abort.
*
* @return {boolean}
* Returns `true` if animation continues.
*/
step: function (gotoEnd) {
var t = +new Date(),
ret,
done,
options = this.options,
elem = this.elem,
complete = options.complete,
duration = options.duration,
curAnim = options.curAnim;
if (elem.attr && !elem.element) { // #2616, element is destroyed
ret = false;
} else if (gotoEnd || t >= duration + this.startTime) {
this.now = this.end;
this.pos = 1;
this.update();
curAnim[this.prop] = true;
done = true;
H.objectEach(curAnim, function (val) {
if (val !== true) {
done = false;
}
});
if (done && complete) {
complete.call(elem);
}
ret = false;
} else {
this.pos = options.easing((t - this.startTime) / duration);
this.now = this.start + ((this.end - this.start) * this.pos);
this.update();
ret = true;
}
return ret;
},
/**
* Prepare start and end values so that the path can be animated one to one.
*
* @function Highcharts.Fx#initPath
*
* @param {Highcharts.SVGElement} elem
* The SVGElement item.
*
* @param {string} fromD
* Starting path definition.
*
* @param {Highcharts.SVGPathArray} toD
* Ending path definition.
*
* @return {Array<Highcharts.SVGPathArray>}
* An array containing start and end paths in array form so that
* they can be animated in parallel.
*/
initPath: function (elem, fromD, toD) {
fromD = fromD || '';
var shift,
startX = elem.startX,
endX = elem.endX,
bezier = fromD.indexOf('C') > -1,
numParams = bezier ? 7 : 3,
fullLength,
slice,
i,
start = fromD.split(' '),
end = toD.slice(), // copy
isArea = elem.isArea,
positionFactor = isArea ? 2 : 1,
reverse;
/**
* In splines make moveTo and lineTo points have six parameters like
* bezier curves, to allow animation one-to-one.
*/
function sixify(arr) {
var isOperator,
nextIsOperator;
i = arr.length;
while (i--) {
// Fill in dummy coordinates only if the next operator comes
// three places behind (#5788)
isOperator = arr[i] === 'M' || arr[i] === 'L';
nextIsOperator = /[a-zA-Z]/.test(arr[i + 3]);
if (isOperator && nextIsOperator) {
arr.splice(
i + 1, 0,
arr[i + 1], arr[i + 2],
arr[i + 1], arr[i + 2]
);
}
}
}
/**
* Insert an array at the given position of another array
*/
function insertSlice(arr, subArr, index) {
[].splice.apply(
arr,
[index, 0].concat(subArr)
);
}
/**
* If shifting points, prepend a dummy point to the end path.
*/
function prepend(arr, other) {
while (arr.length < fullLength) {
// Move to, line to or curve to?
arr[0] = other[fullLength - arr.length];
// Prepend a copy of the first point
insertSlice(arr, arr.slice(0, numParams), 0);
// For areas, the bottom path goes back again to the left, so we
// need to append a copy of the last point.
if (isArea) {
insertSlice(
arr,
arr.slice(arr.length - numParams), arr.length
);
i--;
}
}
arr[0] = 'M';
}
/**
* Copy and append last point until the length matches the end length.
*/
function append(arr, other) {
var i = (fullLength - arr.length) / numParams;
while (i > 0 && i--) {
// Pull out the slice that is going to be appended or inserted.
// In a line graph, the positionFactor is 1, and the last point
// is sliced out. In an area graph, the positionFactor is 2,
// causing the middle two points to be sliced out, since an area
// path starts at left, follows the upper path then turns and
// follows the bottom back.
slice = arr.slice().splice(
(arr.length / positionFactor) - numParams,
numParams * positionFactor
);
// Move to, line to or curve to?
slice[0] = other[fullLength - numParams - (i * numParams)];
// Disable first control point
if (bezier) {
slice[numParams - 6] = slice[numParams - 2];
slice[numParams - 5] = slice[numParams - 1];
}
// Now insert the slice, either in the middle (for areas) or at
// the end (for lines)
insertSlice(arr, slice, arr.length / positionFactor);
if (isArea) {
i--;
}
}
}
if (bezier) {
sixify(start);
sixify(end);
}
// For sideways animation, find out how much we need to shift to get the
// start path Xs to match the end path Xs.
if (startX && endX) {
for (i = 0; i < startX.length; i++) {
// Moving left, new points coming in on right
if (startX[i] === endX[0]) {
shift = i;
break;
// Moving right
} else if (startX[0] ===
endX[endX.length - startX.length + i]) {
shift = i;
reverse = true;
break;
}
}
if (shift === undefined) {
start = [];
}
}
if (start.length && H.isNumber(shift)) {
// The common target length for the start and end array, where both
// arrays are padded in opposite ends
fullLength = end.length + shift * positionFactor * numParams;
if (!reverse) {
prepend(end, start);
append(start, end);
} else {
prepend(start, end);
append(end, start);
}
}
return [start, end];
},
/**
* Handle animation of the color attributes directly.
*
* @function Highcharts.Fx#fillSetter
*/
fillSetter: function () {
H.Fx.prototype.strokeSetter.apply(this, arguments);
},
/**
* Handle animation of the color attributes directly.
*
* @function Highcharts.Fx#strokeSetter
*/
strokeSetter: function () {
this.elem.attr(
this.prop,
H.color(this.start).tweenTo(H.color(this.end), this.pos),
null,
true
);
}
}; // End of Fx prototype
/**
* Utility function to deep merge two or more objects and return a third object.
* The merge function can also be used with a single object argument to create a
* deep copy of an object.
*
* @function Highcharts.merge
*
* @param {*} a
* The first object to extend. When only this is given, the function
* returns a deep copy.
*
* @param {*} [n]
* An object to merge into the previous one.
*
* @return {*}
* The merged object. If the first argument is true, the return is the
* same as the second argument.
*//**
* Utility function to deep merge two or more objects and return a third object.
* If the first argument is true, the contents of the second object is copied
* into the first object. The merge function can also be used with a single
* object argument to create a deep copy of an object.
*
* @function Highcharts.merge
*
* @param {boolean} extend
* Whether to extend the left-side object (a) or return a whole new
* object.
*
* @param {*} a
* The first object to extend. When only this is given, the function
* returns a deep copy.
*
* @param {*} [n]
* An object to merge into the previous one.
*
* @return {*}
* The merged object. If the first argument is true, the return is the
* same as the second argument.
*/
H.merge = function () {
var i,
args = arguments,
len,
ret = {},
doCopy = function (copy, original) {
// An object is replacing a primitive
if (typeof copy !== 'object') {
copy = {};
}
H.objectEach(original, function (value, key) {
// Copy the contents of objects, but not arrays or DOM nodes
if (
H.isObject(value, true) &&
!H.isClass(value) &&
!H.isDOMElement(value)
) {
copy[key] = doCopy(copy[key] || {}, value);
// Primitives and arrays are copied over directly
} else {
copy[key] = original[key];
}
});
return copy;
};
// If first argument is true, copy into the existing object. Used in
// setOptions.
if (args[0] === true) {
ret = args[1];
args = Array.prototype.slice.call(args, 2);
}
// For each argument, extend the return
len = args.length;
for (i = 0; i < len; i++) {
ret = doCopy(ret, args[i]);
}
return ret;
};
/**
* Shortcut for parseInt
*
* @private
* @function Highcharts.pInt
*
* @param {*} s
*
* @param {number} mag
* Magnitude
*
* @return {number}
*/
H.pInt = function (s, mag) {
return parseInt(s, mag || 10);
};
/**
* Utility function to check for string type.
*
* @function Highcharts.isString
*
* @param {*} s
* The item to check.
*
* @return {boolean}
* True if the argument is a string.
*/
H.isString = function (s) {
return typeof s === 'string';
};
/**
* Utility function to check if an item is an array.
*
* @function Highcharts.isArray
*
* @param {*} obj
* The item to check.
*
* @return {boolean}
* True if the argument is an array.
*/
H.isArray = function (obj) {
var str = Object.prototype.toString.call(obj);
return str === '[object Array]' || str === '[object Array Iterator]';
};
/**
* Utility function to check if an item is of type object.
*
* @function Highcharts.isObject
*
* @param {*} obj
* The item to check.
*
* @param {boolean} [strict=false]
* Also checks that the object is not an array.
*
* @return {boolean}
* True if the argument is an object.
*/
H.isObject = function (obj, strict) {
return !!obj && typeof obj === 'object' && (!strict || !H.isArray(obj));
};
/**
* Utility function to check if an Object is a HTML Element.
*
* @function Highcharts.isDOMElement
*
* @param {*} obj
* The item to check.
*
* @return {boolean}
* True if the argument is a HTML Element.
*/
H.isDOMElement = function (obj) {
return H.isObject(obj) && typeof obj.nodeType === 'number';
};
/**
* Utility function to check if an Object is an class.
*
* @function Highcharts.isClass
*
* @param {*} obj
* The item to check.
*
* @return {boolean}
* True if the argument is an class.
*/
H.isClass = function (obj) {
var c = obj && obj.constructor;
return !!(
H.isObject(obj, true) &&
!H.isDOMElement(obj) &&
(c && c.name && c.name !== 'Object')
);
};
/**
* Utility function to check if an item is a number and it is finite (not NaN,
* Infinity or -Infinity).
*
* @function Highcharts.isNumber
*
* @param {*} n
* The item to check.
*
* @return {boolean}
* True if the item is a finite number
*/
H.isNumber = function (n) {
return typeof n === 'number' && !isNaN(n) && n < Infinity && n > -Infinity;
};
/**
* Remove the last occurence of an item from an array.
*
* @function Highcharts.erase
*
* @param {Array} arr
* The array.
*
* @param {*} item
* The item to remove.
*/
H.erase = function (arr, item) {
var i = arr.length;
while (i--) {
if (arr[i] === item) {
arr.splice(i, 1);
break;
}
}
};
/**
* Check if an object is null or undefined.
*
* @function Highcharts.defined
*
* @param {*} obj
* The object to check.
*
* @return {boolean}
* False if the object is null or undefined, otherwise true.
*/
H.defined = function (obj) {
return obj !== undefined && obj !== null;
};
/**
* Set or get an attribute or an object of attributes. To use as a setter, pass
* a key and a value, or let the second argument be a collection of keys and
* values. To use as a getter, pass only a string as the second argument.
*
* @function Highcharts.attr
*
* @param {Highcharts.HTMLDOMElement|Highcharts.SVGDOMElement} elem
* The DOM element to receive the attribute(s).
*
* @param {string|Highcharts.HTMLAttributes|Highcharts.SVGAttributes} [prop]
* The property or an object of key-value pairs.
*
* @param {string} [value]
* The value if a single property is set.
*
* @return {*}
* When used as a getter, return the value.
*/
H.attr = function (elem, prop, value) {
var ret;
// if the prop is a string
if (H.isString(prop)) {
// set the value
if (H.defined(value)) {
elem.setAttribute(prop, value);
// get the value
} else if (elem && elem.getAttribute) {
ret = elem.getAttribute(prop);
// IE7 and below cannot get class through getAttribute (#7850)
if (!ret && prop === 'class') {
ret = elem.getAttribute(prop + 'Name');
}
}
// else if prop is defined, it is a hash of key/value pairs
} else if (H.defined(prop) && H.isObject(prop)) {
H.objectEach(prop, function (val, key) {
elem.setAttribute(key, val);
});
}
return ret;
};
/**
* Check if an element is an array, and if not, make it into an array.
*
* @function Highcharts.splat
*
* @param {*} obj
* The object to splat.
*
* @return {Array}
* The produced or original array.
*/
H.splat = function (obj) {
return H.isArray(obj) ? obj : [obj];
};
/**
* Set a timeout if the delay is given, otherwise perform the function
* synchronously.
*
* @function Highcharts.syncTimeout
*
* @param {Function} fn
* The function callback.
*
* @param {number} delay
* Delay in milliseconds.
*
* @param {*} [context]
* The context.
*
* @return {number}
* An identifier for the timeout that can later be cleared with
* Highcharts.clearTimeout.
*/
H.syncTimeout = function (fn, delay, context) {
if (delay) {
return setTimeout(fn, delay, context);
}
fn.call(0, context);
};
/**
* Internal clear timeout. The function checks that the `id` was not removed
* (e.g. by `chart.destroy()`). For the details see
* [issue #7901](https://github.com/highcharts/highcharts/issues/7901).
*
* @function Highcharts.clearTimeout
*
* @param {number} id
* Id of a timeout.
*/
H.clearTimeout = function (id) {
if (H.defined(id)) {
clearTimeout(id);
}
};
/**
* Utility function to extend an object with the members of another.
*
* @function Highcharts.extend
*
* @param {Highcharts.Dictionary<*>} a
* The object to be extended.
*
* @param {Highcharts.Dictionary<*>} b
* The object to add to the first one.
*
* @return {Highcharts.Dictionary<*>}
* Object a, the original object.
*/
H.extend = function (a, b) {
var n;
if (!a) {
a = {};
}
for (n in b) {
a[n] = b[n];
}
return a;
};
/**
* Return the first value that is not null or undefined.
*
* @function Highcharts.pick
*
* @param {...*} items
* Variable number of arguments to inspect.
*
* @return {*}
* The value of the first argument that is not null or undefined.
*/
H.pick = function () {
var args = arguments,
i,
arg,
length = args.length;
for (i = 0; i < length; i++) {
arg = args[i];
if (arg !== undefined && arg !== null) {
return arg;
}
}
};
/**
* Set CSS on a given element.
*
* @function Highcharts.css
*
* @param {Highcharts.HTMLDOMElement} el
* An HTML DOM element.
*
* @param {Highcharts.CSSObject} styles
* Style object with camel case property names.
*/
H.css = function (el, styles) {
if (H.isMS && !H.svg) { // #2686
if (styles && styles.opacity !== undefined) {
styles.filter = 'alpha(opacity=' + (styles.opacity * 100) + ')';
}
}
H.extend(el.style, styles);
};
/**
* Utility function to create an HTML element with attributes and styles.
*
* @function Highcharts.createElement
*
* @param {string} tag
* The HTML tag.
*
* @param {Highcharts.HTMLAttributes} [attribs]
* Attributes as an object of key-value pairs.
*
* @param {Highcharts.CSSObject} [styles]
* Styles as an object of key-value pairs.
*
* @param {Highcharts.HTMLDOMElement} [parent]
* The parent HTML object.
*
* @param {boolean} [nopad=false]
* If true, remove all padding, border and margin.
*
* @return {Highcharts.HTMLDOMElement}
* The created DOM element.
*/
H.createElement = function (tag, attribs, styles, parent, nopad) {
var el = doc.createElement(tag),
css = H.css;
if (attribs) {
H.extend(el, attribs);
}
if (nopad) {
css(el, { padding: 0, border: 'none', margin: 0 });
}
if (styles) {
css(el, styles);
}
if (parent) {
parent.appendChild(el);
}
return el;
};
/**
* Extend a prototyped class by new members.
*
* @function Highcharts.extendClass
*
* @param {*} parent
* The parent prototype to inherit.
*
* @param {Highcharts.Dictionary<*>} members
* A collection of prototype members to add or override compared to the
* parent prototype.
*
* @return {*}
* A new prototype.
*/
H.extendClass = function (parent, members) {
var object = function () {};
object.prototype = new parent(); // eslint-disable-line new-cap
H.extend(object.prototype, members);
return object;
};
/**
* Left-pad a string to a given length by adding a character repetetively.
*
* @function Highcharts.pad
*
* @param {number} number
* The input string or number.
*
* @param {number} length
* The desired string length.
*
* @param {string} [padder=0]
* The character to pad with.
*
* @return {string}
* The padded string.
*/
H.pad = function (number, length, padder) {
return new Array(
(length || 2) +
1 -
String(number)
.replace('-', '')
.length
).join(padder || 0) + number;
};
/**
* Return a length based on either the integer value, or a percentage of a base.
*
* @function Highcharts.relativeLength
*
* @param {Highcharts.RelativeSize} value
* A percentage string or a number.
*
* @param {number} base
* The full length that represents 100%.
*
* @param {number} [offset=0]
* A pixel offset to apply for percentage values. Used internally in
* axis positioning.
*
* @return {number}
* The computed length.
*/
H.relativeLength = function (value, base, offset) {
return (/%$/).test(value) ?
(base * parseFloat(value) / 100) + (offset || 0) :
parseFloat(value);
};
/**
* Wrap a method with extended functionality, preserving the original function.
*
* @function Highcharts.wrap
*
* @param {*} obj
* The context object that the method belongs to. In real cases, this is
* often a prototype.
*
* @param {string} method
* The name of the method to extend.
*
* @param {Function} func
* A wrapper function callback. This function is called with the same
* arguments as the original function, except that the original function
* is unshifted and passed as the first argument.
*/
H.wrap = function (obj, method, func) {
var proceed = obj[method];
obj[method] = function () {
var args = Array.prototype.slice.call(arguments),
outerArgs = arguments,
ctx = this,
ret;
ctx.proceed = function () {
proceed.apply(ctx, arguments.length ? arguments : outerArgs);
};
args.unshift(proceed);
ret = func.apply(this, args);
ctx.proceed = null;
return ret;
};
};
/**
* Recursively converts all Date properties to timestamps.
*
* @param {Object} object - any object to convert properties of
*/
H.datePropsToTimestamps = function (object) {
H.objectEach(object, function (val, key) {
if (H.isObject(val) && typeof val.getTime === 'function') {
object[key] = val.getTime();
} else if (H.isObject(val) || H.isArray(val)) {
H.datePropsToTimestamps(val);
}
});
};
/**
* Format a single variable. Similar to sprintf, without the % prefix.
*
* @example
* formatSingle('.2f', 5); // => '5.00'.
*
* @function Highcharts.formatSingle
*
* @param {string} format
* The format string.
*
* @param {*} val
* The value.
*
* @param {Highcharts.Time} [time]
* A `Time` instance that determines the date formatting, for example
* for applying time zone corrections to the formatted date.
*
* @return {string}
* The formatted representation of the value.
*/
H.formatSingle = function (format, val, time) {
var floatRegex = /f$/,
decRegex = /\.([0-9])/,
lang = H.defaultOptions.lang,
decimals;
if (floatRegex.test(format)) { // float
decimals = format.match(decRegex);
decimals = decimals ? decimals[1] : -1;
if (val !== null) {
val = H.numberFormat(
val,
decimals,
lang.decimalPoint,
format.indexOf(',') > -1 ? lang.thousandsSep : ''
);
}
} else {
val = (time || H.time).dateFormat(format, val);
}
return val;
};
/**
* Format a string according to a subset of the rules of Python's String.format
* method.
*
* @example
* var s = Highcharts.format(
* 'The {color} fox was {len:.2f} feet long',
* { color: 'red', len: Math.PI }
* );
* // => The red fox was 3.14 feet long
*
* @function Highcharts.format
*
* @param {string} str
* The string to format.
*
* @param {*} ctx
* The context, a collection of key-value pairs where each key is
* replaced by its value.
*
* @param {Highcharts.Time} [time]
* A `Time` instance that determines the date formatting, for example
* for applying time zone corrections to the formatted date.
*
* @return {string}
* The formatted string.
*/
H.format = function (str, ctx, time) {
var splitter = '{',
isInside = false,
segment,
valueAndFormat,
path,
i,
len,
ret = [],
val,
index;
while (str) {
index = str.indexOf(splitter);
if (index === -1) {
break;
}
segment = str.slice(0, index);
if (isInside) { // we're on the closing bracket looking back
valueAndFormat = segment.split(':');
path = valueAndFormat.shift().split('.'); // get first and leave
len = path.length;
val = ctx;
// Assign deeper paths
for (i = 0; i < len; i++) {
if (val) {
val = val[path[i]];
}
}
// Format the replacement
if (valueAndFormat.length) {
val = H.formatSingle(valueAndFormat.join(':'), val, time);
}
// Push the result and advance the cursor
ret.push(val);
} else {
ret.push(segment);
}
str = str.slice(index + 1); // the rest
isInside = !isInside; // toggle
splitter = isInside ? '}' : '{'; // now look for next matching bracket
}
ret.push(str);
return ret.join('');
};
/**
* Get the magnitude of a number.
*
* @function Highcharts.getMagnitude
*
* @param {number} number
* The number.
*
* @return {number}
* The magnitude, where 1-9 are magnitude 1, 10-99 magnitude 2 etc.
*/
H.getMagnitude = function (num) {
return Math.pow(10, Math.floor(Math.log(num) / Math.LN10));
};
/**
* Take an interval and normalize it to multiples of round numbers.
*
* @deprecated
* @function Highcharts.normalizeTickInterval
*
* @param {number} interval
* The raw, un-rounded interval.
*
* @param {Array} [multiples]
* Allowed multiples.
*
* @param {number} [magnitude]
* The magnitude of the number.
*
* @param {boolean} [allowDecimals]
* Whether to allow decimals.
*
* @param {boolean} [hasTickAmount]
* If it has tickAmount, avoid landing on tick intervals lower than
* original.
*
* @return {number}
* The normalized interval.
*
* @todo
* Move this function to the Axis prototype. It is here only for historical
* reasons.
*/
H.normalizeTickInterval = function (interval, multiples, magnitude,
allowDecimals, hasTickAmount) {
var normalized,
i,
retInterval = interval;
// round to a tenfold of 1, 2, 2.5 or 5
magnitude = H.pick(magnitude, 1);
normalized = interval / magnitude;
// multiples for a linear scale
if (!multiples) {
multiples = hasTickAmount ?
// Finer grained ticks when the tick amount is hard set, including
// when alignTicks is true on multiple axes (#4580).
[1, 1.2, 1.5, 2, 2.5, 3, 4, 5, 6, 8, 10] :
// Else, let ticks fall on rounder numbers
[1, 2, 2.5, 5, 10];
// the allowDecimals option
if (allowDecimals === false) {
if (magnitude === 1) {
multiples = H.grep(multiples, function (num) {
return num % 1 === 0;
});
} else if (magnitude <= 0.1) {
multiples = [1 / magnitude];
}
}
}
// normalize the interval to the nearest multiple
for (i = 0; i < multiples.length; i++) {
retInterval = multiples[i];
// only allow tick amounts smaller than natural
if (
(
hasTickAmount &&
retInterval * magnitude >= interval
) ||
(
!hasTickAmount &&
(
normalized <=
(
multiples[i] +
(multiples[i + 1] || multiples[i])
) / 2
)
)
) {
break;
}
}
// Multiply back to the correct magnitude. Correct floats to appropriate
// precision (#6085).
retInterval = H.correctFloat(
retInterval * magnitude,
-Math.round(Math.log(0.001) / Math.LN10)
);
return retInterval;
};
/**
* Sort an object array and keep the order of equal items. The ECMAScript
* standard does not specify the behaviour when items are equal.
*
* @function Highcharts.stableSort
*
* @param {Array} arr
* The array to sort.
*
* @param {Function} sortFunction
* The function to sort it with, like with regular Array.prototype.sort.
*/
H.stableSort = function (arr, sortFunction) {
var length = arr.length,
sortValue,
i;
// Add index to each item
for (i = 0; i < length; i++) {
arr[i].safeI = i; // stable sort index
}
arr.sort(function (a, b) {
sortValue = sortFunction(a, b);
return sortValue === 0 ? a.safeI - b.safeI : sortValue;
});
// Remove index from items
for (i = 0; i < length; i++) {
delete arr[i].safeI; // stable sort index
}
};
/**
* Non-recursive method to find the lowest member of an array. `Math.min` raises
* a maximum call stack size exceeded error in Chrome when trying to apply more
* than 150.000 points. This method is slightly slower, but safe.
*
* @function Highcharts.arrayMin
*
* @param {Array} data
* An array of numbers.
*
* @return {number}
* The lowest number.
*/
H.arrayMin = function (data) {
var i = data.length,
min = data[0];
while (i--) {
if (data[i] < min) {
min = data[i];
}
}
return min;
};
/**
* Non-recursive method to find the lowest member of an array. `Math.max` raises
* a maximum call stack size exceeded error in Chrome when trying to apply more
* than 150.000 points. This method is slightly slower, but safe.
*
* @function Highcharts.arrayMax
*
* @param {Array} data
* An array of numbers.
*
* @return {number}
* The highest number.
*/
H.arrayMax = function (data) {
var i = data.length,
max = data[0];
while (i--) {
if (data[i] > max) {
max = data[i];
}
}
return max;
};
/**
* Utility method that destroys any SVGElement instances that are properties on
* the given object. It loops all properties and invokes destroy if there is a
* destroy method. The property is then delete.
*
* @function Highcharts.destroyObjectProperties
*
* @param {*} obj
* The object to destroy properties on.
*
* @param {*} [except]
* Excepti