nucleo/Sensores
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Carga

Browse Source 
Carga
This commit is contained in:
Antonio Espiritu
2025-04-17 00:35:33 -06:00
parent 4977462629
commit 67fc72aed5
1333 changed files with 1077639 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

663
static/lib/Highcharts-10.2.1/es-modules/Series/AreaRange/AreaRangeSeries.js Normal file
View File

@@ -0,0 +1,663 @@
/* *
*
* (c) 2010-2021 Torstein Honsi
*
* License: www.highcharts.com/license
*
* !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
*
* */
'use strict';
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
if (typeof b !== "function" && b !== null)
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
import AreaRangePoint from './AreaRangePoint.js';
import H from '../../Core/Globals.js';
var noop = H.noop;
import SeriesRegistry from '../../Core/Series/SeriesRegistry.js';
var _a = SeriesRegistry.seriesTypes, AreaSeries = _a.area, areaProto = _a.area.prototype, columnProto = _a.column.prototype;
import U from '../../Core/Utilities.js';
var defined = U.defined, extend = U.extend, isArray = U.isArray, pick = U.pick, merge = U.merge;
/* *
*
* Constants
*
* */
/**
* The area range series is a carteseian series with higher and lower values for
* each point along an X axis, where the area between the values is shaded.
*
* @sample {highcharts} highcharts/demo/arearange/
* Area range chart
* @sample {highstock} stock/demo/arearange/
* Area range chart
*
* @extends plotOptions.area
* @product highcharts highstock
* @excluding stack, stacking
* @requires highcharts-more
* @optionparent plotOptions.arearange
*
* @private
*/
var areaRangeSeriesOptions = {
/**
* @see [fillColor](#plotOptions.arearange.fillColor)
* @see [fillOpacity](#plotOptions.arearange.fillOpacity)
*
* @apioption plotOptions.arearange.color
*/
/**
* @default low
* @apioption plotOptions.arearange.colorKey
*/
/**
* @see [color](#plotOptions.arearange.color)
* @see [fillOpacity](#plotOptions.arearange.fillOpacity)
*
* @apioption plotOptions.arearange.fillColor
*/
/**
* @see [color](#plotOptions.arearange.color)
* @see [fillColor](#plotOptions.arearange.fillColor)
*
* @default {highcharts} 0.75
* @default {highstock} 0.75
* @apioption plotOptions.arearange.fillOpacity
*/
/**
* Whether to apply a drop shadow to the graph line. Since 2.3 the
* shadow can be an object configuration containing `color`, `offsetX`,
* `offsetY`, `opacity` and `width`.
*
* @type {boolean|Highcharts.ShadowOptionsObject}
* @product highcharts
* @apioption plotOptions.arearange.shadow
*/
/**
* Pixel width of the arearange graph line.
*
* @since 2.3.0
*
* @private
*/
lineWidth: 1,
threshold: null,
tooltip: {
pointFormat: '<span style="color:{series.color}">\u25CF</span> ' +
'{series.name}: <b>{point.low}</b> - <b>{point.high}</b><br/>'
},
/**
* Whether the whole area or just the line should respond to mouseover
* tooltips and other mouse or touch events.
*
* @since 2.3.0
*
* @private
*/
trackByArea: true,
/**
* Extended data labels for range series types. Range series data
* labels use no `x` and `y` options. Instead, they have `xLow`,
* `xHigh`, `yLow` and `yHigh` options to allow the higher and lower
* data label sets individually.
*
* @declare Highcharts.SeriesAreaRangeDataLabelsOptionsObject
* @exclude x, y
* @since 2.3.0
* @product highcharts highstock
*
* @private
*/
dataLabels: {
align: void 0,
verticalAlign: void 0,
/**
* X offset of the lower data labels relative to the point value.
*
* @sample highcharts/plotoptions/arearange-datalabels/
* Data labels on range series
* @sample highcharts/plotoptions/arearange-datalabels/
* Data labels on range series
*/
xLow: 0,
/**
* X offset of the higher data labels relative to the point value.
*
* @sample highcharts/plotoptions/arearange-datalabels/
* Data labels on range series
*/
xHigh: 0,
/**
* Y offset of the lower data labels relative to the point value.
*
* @sample highcharts/plotoptions/arearange-datalabels/
* Data labels on range series
*/
yLow: 0,
/**
* Y offset of the higher data labels relative to the point value.
*
* @sample highcharts/plotoptions/arearange-datalabels/
* Data labels on range series
*/
yHigh: 0
}
};
/* *
*
* Class
*
* */
/**
* The AreaRange series type.
*
* @private
* @class
* @name Highcharts.seriesTypes.arearange
*
* @augments Highcharts.Series
*/
var AreaRangeSeries = /** @class */ (function (_super) {
__extends(AreaRangeSeries, _super);
function AreaRangeSeries() {
/**
*
* Static Properties
*
*/
var _this = _super !== null && _super.apply(this, arguments) || this;
/* *
*
* Properties
*
* */
_this.data = void 0;
_this.options = void 0;
_this.points = void 0;
_this.lowerStateMarkerGraphic = void 0;
_this.xAxis = void 0;
return _this;
}
/* *
*
* Functions
*
* */
AreaRangeSeries.prototype.toYData = function (point) {
return [point.low, point.high];
};
/**
* Translate a point's plotHigh from the internal angle and radius measures
* to true plotHigh coordinates. This is an addition of the toXY method
* found in Polar.js, because it runs too early for arearanges to be
* considered (#3419).
* @private
*/
AreaRangeSeries.prototype.highToXY = function (point) {
// Find the polar plotX and plotY
var chart = this.chart, xy = this.xAxis.postTranslate(point.rectPlotX || 0, this.yAxis.len - point.plotHigh);
point.plotHighX = xy.x - chart.plotLeft;
point.plotHigh = xy.y - chart.plotTop;
point.plotLowX = point.plotX;
};
/**
* Translate data points from raw values x and y to plotX and plotY.
* @private
*/
AreaRangeSeries.prototype.translate = function () {
var series = this;
areaProto.translate.apply(series);
// Set plotLow and plotHigh
series.points.forEach(function (point, i) {
var high = point.high, plotY = point.plotY;
if (point.isNull) {
point.plotY = null;
}
else {
var yAxis = series.chart.hasParallelCoordinates ?
series.chart.yAxis[i] :
series.yAxis;
point.plotLow = plotY;
// Calculate plotHigh value based on each yAxis scale (#15752)
point.plotHigh = yAxis.translate(series.dataModify ?
series.dataModify.modifyValue(high) : high, 0, 1, 0, 1);
if (series.dataModify) {
point.yBottom = point.plotHigh;
}
}
});
// Postprocess plotHigh
if (this.chart.polar) {
this.points.forEach(function (point) {
series.highToXY(point);
point.tooltipPos = [
(point.plotHighX + point.plotLowX) / 2,
(point.plotHigh + point.plotLow) / 2
];
});
}
};
/**
* Extend the line series' getSegmentPath method by applying the segment
* path to both lower and higher values of the range.
* @private
*/
AreaRangeSeries.prototype.getGraphPath = function (points) {
var highPoints = [], highAreaPoints = [], getGraphPath = areaProto.getGraphPath, options = this.options, polar = this.chart.polar, connectEnds = polar && options.connectEnds !== false, connectNulls = options.connectNulls;
var i, point, pointShim, step = options.step;
points = points || this.points;
// Create the top line and the top part of the area fill. The area fill
// compensates for null points by drawing down to the lower graph,
// moving across the null gap and starting again at the lower graph.
i = points.length;
while (i--) {
point = points[i];
// Support for polar
var highAreaPoint = polar ? {
plotX: point.rectPlotX,
plotY: point.yBottom,
doCurve: false // #5186, gaps in areasplinerange fill
} : {
plotX: point.plotX,
plotY: point.plotY,
doCurve: false // #5186, gaps in areasplinerange fill
};
if (!point.isNull &&
!connectEnds &&
!connectNulls &&
(!points[i + 1] || points[i + 1].isNull)) {
highAreaPoints.push(highAreaPoint);
}
pointShim = {
polarPlotY: point.polarPlotY,
rectPlotX: point.rectPlotX,
yBottom: point.yBottom,
// plotHighX is for polar charts
plotX: pick(point.plotHighX, point.plotX),
plotY: point.plotHigh,
isNull: point.isNull
};
highAreaPoints.push(pointShim);
highPoints.push(pointShim);
if (!point.isNull &&
!connectEnds &&
!connectNulls &&
(!points[i - 1] || points[i - 1].isNull)) {
highAreaPoints.push(highAreaPoint);
}
}
// Get the paths
var lowerPath = getGraphPath.call(this, points);
if (step) {
if (step === true) {
step = 'left';
}
options.step = {
left: 'right',
center: 'center',
right: 'left'
}[step]; // swap for reading in getGraphPath
}
var higherPath = getGraphPath.call(this, highPoints);
var higherAreaPath = getGraphPath.call(this, highAreaPoints);
options.step = step;
// Create a line on both top and bottom of the range
var linePath = [].concat(lowerPath, higherPath);
// For the area path, we need to change the 'move' statement into
// 'lineTo'
if (!this.chart.polar &&
higherAreaPath[0] &&
higherAreaPath[0][0] === 'M') {
// This probably doesn't work for spline
higherAreaPath[0] = [
'L',
higherAreaPath[0][1],
higherAreaPath[0][2]
];
}
this.graphPath = linePath;
this.areaPath = lowerPath.concat(higherAreaPath);
// Prepare for sideways animation
linePath.isArea = true;
linePath.xMap = lowerPath.xMap;
this.areaPath.xMap = lowerPath.xMap;
return linePath;
};
/**
* Extend the basic drawDataLabels method by running it for both lower and
* higher values.
* @private
*/
AreaRangeSeries.prototype.drawDataLabels = function () {
var data = this.points, length = data.length, originalDataLabels = [], dataLabelOptions = this.options.dataLabels, inverted = this.chart.inverted;
var i, point, up, upperDataLabelOptions, lowerDataLabelOptions;
if (dataLabelOptions) {
// Split into upper and lower options. If data labels is an array,
// the first element is the upper label, the second is the lower.
//
// TODO: We want to change this and allow multiple labels for both
// upper and lower values in the future - introducing some options
// for which point value to use as Y for the dataLabel, so that this
// could be handled in Series.drawDataLabels. This would also
// improve performance since we now have to loop over all the points
// multiple times to work around the data label logic.
if (isArray(dataLabelOptions)) {
upperDataLabelOptions = dataLabelOptions[0] || {
enabled: false
};
lowerDataLabelOptions = dataLabelOptions[1] || {
enabled: false
};
}
else {
// Make copies
upperDataLabelOptions = extend({}, dataLabelOptions);
upperDataLabelOptions.x = dataLabelOptions.xHigh;
upperDataLabelOptions.y = dataLabelOptions.yHigh;
lowerDataLabelOptions = extend({}, dataLabelOptions);
lowerDataLabelOptions.x = dataLabelOptions.xLow;
lowerDataLabelOptions.y = dataLabelOptions.yLow;
}
// Draw upper labels
if (upperDataLabelOptions.enabled || this._hasPointLabels) {
// Set preliminary values for plotY and dataLabel
// and draw the upper labels
i = length;
while (i--) {
point = data[i];
if (point) {
up = upperDataLabelOptions.inside ?
point.plotHigh < point.plotLow :
point.plotHigh > point.plotLow;
point.y = point.high;
point._plotY = point.plotY;
point.plotY = point.plotHigh;
// Store original data labels and set preliminary label
// objects to be picked up in the uber method
originalDataLabels[i] = point.dataLabel;
point.dataLabel = point.dataLabelUpper;
// Set the default offset
point.below = up;
if (inverted) {
if (!upperDataLabelOptions.align) {
upperDataLabelOptions.align = up ?
'right' : 'left';
}
}
else {
if (!upperDataLabelOptions.verticalAlign) {
upperDataLabelOptions.verticalAlign = up ?
'top' :
'bottom';
}
}
}
}
this.options.dataLabels = upperDataLabelOptions;
if (areaProto.drawDataLabels) {
// #1209:
areaProto.drawDataLabels.apply(this, arguments);
}
// Reset state after the upper labels were created. Move
// it to point.dataLabelUpper and reassign the originals.
// We do this here to support not drawing a lower label.
i = length;
while (i--) {
point = data[i];
if (point) {
point.dataLabelUpper = point.dataLabel;
point.dataLabel = originalDataLabels[i];
delete point.dataLabels;
point.y = point.low;
point.plotY = point._plotY;
}
}
}
// Draw lower labels
if (lowerDataLabelOptions.enabled || this._hasPointLabels) {
i = length;
while (i--) {
point = data[i];
if (point) {
up = lowerDataLabelOptions.inside ?
point.plotHigh < point.plotLow :
point.plotHigh > point.plotLow;
// Set the default offset
point.below = !up;
if (inverted) {
if (!lowerDataLabelOptions.align) {
lowerDataLabelOptions.align = up ?
'left' : 'right';
}
}
else {
if (!lowerDataLabelOptions.verticalAlign) {
lowerDataLabelOptions.verticalAlign = up ?
'bottom' :
'top';
}
}
}
}
this.options.dataLabels = lowerDataLabelOptions;
if (areaProto.drawDataLabels) {
areaProto.drawDataLabels.apply(this, arguments);
}
}
// Merge upper and lower into point.dataLabels for later destroying
if (upperDataLabelOptions.enabled) {
i = length;
while (i--) {
point = data[i];
if (point) {
point.dataLabels = [
point.dataLabelUpper,
point.dataLabel
].filter(function (label) {
return !!label;
});
}
}
}
// Reset options
this.options.dataLabels = dataLabelOptions;
}
};
AreaRangeSeries.prototype.alignDataLabel = function () {
columnProto.alignDataLabel.apply(this, arguments);
};
AreaRangeSeries.prototype.drawPoints = function () {
var series = this, pointLength = series.points.length;
var i, point;
// Draw bottom points
areaProto.drawPoints.apply(series, arguments);
// Prepare drawing top points
i = 0;
while (i < pointLength) {
point = series.points[i];
// Save original props to be overridden by temporary props for top
// points
point.origProps = {
plotY: point.plotY,
plotX: point.plotX,
isInside: point.isInside,
negative: point.negative,
zone: point.zone,
y: point.y
};
point.lowerGraphic = point.graphic;
point.graphic = point.upperGraphic;
point.plotY = point.plotHigh;
if (defined(point.plotHighX)) {
point.plotX = point.plotHighX;
}
point.y = pick(point.high, point.origProps.y); // #15523
point.negative = point.y < (series.options.threshold || 0);
if (series.zones.length) {
point.zone = point.getZone();
}
if (!series.chart.polar) {
point.isInside = point.isTopInside = (typeof point.plotY !== 'undefined' &&
point.plotY >= 0 &&
point.plotY <= series.yAxis.len && // #3519
point.plotX >= 0 &&
point.plotX <= series.xAxis.len);
}
i++;
}
// Draw top points
areaProto.drawPoints.apply(series, arguments);
// Reset top points preliminary modifications
i = 0;
while (i < pointLength) {
point = series.points[i];
point.upperGraphic = point.graphic;
point.graphic = point.lowerGraphic;
if (point.origProps) {
extend(point, point.origProps);
delete point.origProps;
}
i++;
}
};
AreaRangeSeries.defaultOptions = merge(AreaSeries.defaultOptions, areaRangeSeriesOptions);
return AreaRangeSeries;
}(AreaSeries));
extend(AreaRangeSeries.prototype, {
deferTranslatePolar: true,
pointArrayMap: ['low', 'high'],
pointClass: AreaRangePoint,
pointValKey: 'low',
setStackedPoints: noop
});
SeriesRegistry.registerSeriesType('arearange', AreaRangeSeries);
/* *
*
* Default Export
*
* */
export default AreaRangeSeries;
/* *
*
* API Options
*
* */
/**
* A `arearange` series. If the [type](#series.arearange.type) option is not
* specified, it is inherited from [chart.type](#chart.type).
*
*
* @extends series,plotOptions.arearange
* @excluding dataParser, dataURL, stack, stacking
* @product highcharts highstock
* @requires highcharts-more
* @apioption series.arearange
*/
/**
* @see [fillColor](#series.arearange.fillColor)
* @see [fillOpacity](#series.arearange.fillOpacity)
*
* @apioption series.arearange.color
*/
/**
* An array of data points for the series. For the `arearange` series type,
* points can be given in the following ways:
*
* 1. An array of arrays with 3 or 2 values. In this case, the values
* correspond to `x,low,high`. If the first value is a string, it is
* applied as the name of the point, and the `x` value is inferred.
* The `x` value can also be omitted, in which case the inner arrays
* should be of length 2\. Then the `x` value is automatically calculated,
* either starting at 0 and incremented by 1, or from `pointStart`
* and `pointInterval` given in the series options.
* ```js
* data: [
* [0, 8, 3],
* [1, 1, 1],
* [2, 6, 8]
* ]
* ```
*
* 2. An array of objects with named values. The following snippet shows only a
* few settings, see the complete options set below. If the total number of
* data points exceeds the series'
* [turboThreshold](#series.arearange.turboThreshold),
* this option is not available.
* ```js
* data: [{
* x: 1,
* low: 9,
* high: 0,
* name: "Point2",
* color: "#00FF00"
* }, {
* x: 1,
* low: 3,
* high: 4,
* name: "Point1",
* color: "#FF00FF"
* }]
* ```
*
* @sample {highcharts} highcharts/series/data-array-of-arrays/
* Arrays of numeric x and y
* @sample {highcharts} highcharts/series/data-array-of-arrays-datetime/
* Arrays of datetime x and y
* @sample {highcharts} highcharts/series/data-array-of-name-value/
* Arrays of point.name and y
* @sample {highcharts} highcharts/series/data-array-of-objects/
* Config objects
*
* @type {Array<Array<(number|string),number>|Array<(number|string),number,number>|*>}
* @extends series.line.data
* @excluding marker, y
* @product highcharts highstock
* @apioption series.arearange.data
*/
/**
* @extends series.arearange.dataLabels
* @product highcharts highstock
* @apioption series.arearange.data.dataLabels
*/
/**
* @see [color](#series.arearange.color)
* @see [fillOpacity](#series.arearange.fillOpacity)
*
* @apioption series.arearange.fillColor
*/
/**
* @see [color](#series.arearange.color)
* @see [fillColor](#series.arearange.fillColor)
*
* @default {highcharts} 0.75
* @default {highstock} 0.75
* @apioption series.arearange.fillOpacity
*/
/**
* The high or maximum value for each data point.
*
* @type {number}
* @product highcharts highstock
* @apioption series.arearange.data.high
*/
/**
* The low or minimum value for each data point.
*
* @type {number}
* @product highcharts highstock
* @apioption series.arearange.data.low
*/
''; // adds doclets above to tranpiled file