aw-highstock_rails 7.0.3

data/vendor/assets/javascripts/highstock/es-modules/modules/overlapping-datalabels.src.js

@@ -0,0 +1,250 @@
+/* *
+ * Highcharts module to hide overlapping data labels. This module is included in
+ * Highcharts.
+ *
+ * (c) 2009-2019 Torstein Honsi
+ *
+ * License: www.highcharts.com/license
+ */
+
+'use strict';
+
+import H from '../parts/Globals.js';
+import '../parts/Utilities.js';
+import '../parts/Chart.js';
+
+var Chart = H.Chart,
+    isArray = H.isArray,
+    objectEach = H.objectEach,
+    pick = H.pick,
+    addEvent = H.addEvent,
+    fireEvent = H.fireEvent;
+
+// Collect potensial overlapping data labels. Stack labels probably don't need
+// to be considered because they are usually accompanied by data labels that lie
+// inside the columns.
+addEvent(Chart, 'render', function collectAndHide() {
+    var labels = [];
+
+    // Consider external label collectors
+    (this.labelCollectors || []).forEach(function (collector) {
+        labels = labels.concat(collector());
+    });
+
+    (this.yAxis || []).forEach(function (yAxis) {
+        if (
+            yAxis.options.stackLabels &&
+            !yAxis.options.stackLabels.allowOverlap
+        ) {
+            objectEach(yAxis.stacks, function (stack) {
+                objectEach(stack, function (stackItem) {
+                    labels.push(stackItem.label);
+                });
+            });
+        }
+    });
+
+    (this.series || []).forEach(function (series) {
+        var dlOptions = series.options.dataLabels;
+
+        if (
+            series.visible &&
+            !(dlOptions.enabled === false && !series._hasPointLabels)
+        ) { // #3866
+            series.points.forEach(function (point) {
+                if (point.visible) {
+                    var dataLabels = (
+                        isArray(point.dataLabels) ?
+                            point.dataLabels :
+                            (point.dataLabel ? [point.dataLabel] : [])
+                    );
+
+                    dataLabels.forEach(function (label) {
+                        var options = label.options;
+
+                        label.labelrank = pick(
+                            options.labelrank,
+                            point.labelrank,
+                            point.shapeArgs && point.shapeArgs.height
+                        ); // #4118
+
+                        if (!options.allowOverlap) {
+                            labels.push(label);
+                        }
+                    });
+                }
+            });
+        }
+    });
+
+    this.hideOverlappingLabels(labels);
+});
+
+/**
+ * Hide overlapping labels. Labels are moved and faded in and out on zoom to
+ * provide a smooth visual imression.
+ *
+ * @private
+ * @function Highcharts.Chart#hideOverlappingLabels
+ *
+ * @param {Array<Highcharts.SVGElement>} labels
+ */
+Chart.prototype.hideOverlappingLabels = function (labels) {
+
+    var chart = this,
+        len = labels.length,
+        ren = chart.renderer,
+        label,
+        i,
+        j,
+        label1,
+        label2,
+        isIntersecting,
+        box1,
+        box2,
+        intersectRect = function (x1, y1, w1, h1, x2, y2, w2, h2) {
+            return !(
+                x2 > x1 + w1 ||
+                x2 + w2 < x1 ||
+                y2 > y1 + h1 ||
+                y2 + h2 < y1
+            );
+        },
+
+        // Get the box with its position inside the chart, as opposed to getBBox
+        // that only reports the position relative to the parent.
+        getAbsoluteBox = function (label) {
+            var pos,
+                parent,
+                bBox,
+                // Substract the padding if no background or border (#4333)
+                padding = label.box ? 0 : (label.padding || 0),
+                lineHeightCorrection = 0;
+
+            if (
+                label &&
+                (!label.alignAttr || label.placed)
+            ) {
+                pos = label.alignAttr || {
+                    x: label.attr('x'),
+                    y: label.attr('y')
+                };
+                parent = label.parentGroup;
+
+                // Get width and height if pure text nodes (stack labels)
+                if (!label.width) {
+                    bBox = label.getBBox();
+                    label.width = bBox.width;
+                    label.height = bBox.height;
+
+                    // Labels positions are computed from top left corner, so
+                    // we need to substract the text height from text nodes too.
+                    lineHeightCorrection = ren
+                        .fontMetrics(null, label.element).h;
+                }
+                return {
+                    x: pos.x + (parent.translateX || 0) + padding,
+                    y: pos.y + (parent.translateY || 0) + padding -
+                        lineHeightCorrection,
+                    width: label.width - 2 * padding,
+                    height: label.height - 2 * padding
+                };
+
+            }
+        };
+
+    for (i = 0; i < len; i++) {
+        label = labels[i];
+        if (label) {
+
+            // Mark with initial opacity
+            label.oldOpacity = label.opacity;
+            label.newOpacity = 1;
+
+            label.absoluteBox = getAbsoluteBox(label);
+
+        }
+    }
+
+    // Prevent a situation in a gradually rising slope, that each label will
+    // hide the previous one because the previous one always has lower rank.
+    labels.sort(function (a, b) {
+        return (b.labelrank || 0) - (a.labelrank || 0);
+    });
+
+    // Detect overlapping labels
+    for (i = 0; i < len; i++) {
+        label1 = labels[i];
+        box1 = label1 && label1.absoluteBox;
+
+        for (j = i + 1; j < len; ++j) {
+            label2 = labels[j];
+            box2 = label2 && label2.absoluteBox;
+
+            if (
+                box1 &&
+                box2 &&
+                label1 !== label2 && // #6465, polar chart with connectEnds
+                label1.newOpacity !== 0 &&
+                label2.newOpacity !== 0
+            ) {
+                isIntersecting = intersectRect(
+                    box1.x,
+                    box1.y,
+                    box1.width,
+                    box1.height,
+                    box2.x,
+                    box2.y,
+                    box2.width,
+                    box2.height
+                );
+
+
+                if (isIntersecting) {
+                    (label1.labelrank < label2.labelrank ? label1 : label2)
+                        .newOpacity = 0;
+                }
+            }
+        }
+    }
+
+    // Hide or show
+    labels.forEach(function (label) {
+        var complete,
+            newOpacity;
+
+        if (label) {
+            newOpacity = label.newOpacity;
+
+            if (label.oldOpacity !== newOpacity) {
+
+                // Make sure the label is completely hidden to avoid catching
+                // clicks (#4362)
+                if (label.alignAttr && label.placed) { // data labels
+                    if (newOpacity) {
+                        label.show(true);
+                    } else {
+                        complete = function () {
+                            label.hide();
+                        };
+                    }
+
+                    // Animate or set the opacity
+                    label.alignAttr.opacity = newOpacity;
+                    label[label.isOld ? 'animate' : 'attr'](
+                        label.alignAttr,
+                        null,
+                        complete
+                    );
+                    fireEvent(chart, 'afterHideOverlappingLabels');
+                } else { // other labels, tick labels
+                    label.attr({
+                        opacity: newOpacity
+                    });
+                }
+
+            }
+            label.isOld = true;
+        }
+    });
+};

data/vendor/assets/javascripts/highstock/es-modules/modules/parallel-coordinates.src.js

@@ -0,0 +1,492 @@
+/* *
+ * Parallel coordinates module
+ *
+ * (c) 2010-2019 Pawel Fus
+ *
+ * License: www.highcharts.com/license
+ */
+
+'use strict';
+
+import H from '../parts/Globals.js';
+import '../parts/Axis.js';
+import '../parts/Chart.js';
+import '../parts/Series.js';
+
+// Extensions for parallel coordinates plot.
+var Axis = H.Axis,
+    Chart = H.Chart,
+    ChartProto = Chart.prototype,
+    AxisProto = H.Axis.prototype;
+
+var addEvent = H.addEvent,
+    pick = H.pick,
+    wrap = H.wrap,
+    merge = H.merge,
+    erase = H.erase,
+    splat = H.splat,
+    extend = H.extend,
+    defined = H.defined,
+    arrayMin = H.arrayMin,
+    arrayMax = H.arrayMax;
+
+var defaultXAxisOptions = {
+    lineWidth: 0,
+    tickLength: 0,
+    opposite: true,
+    type: 'category'
+};
+
+/**
+ * @optionparent chart
+ */
+var defaultParallelOptions = {
+    /**
+     * Flag to render charts as a parallel coordinates plot. In a parallel
+     * coordinates plot (||-coords) by default all required yAxes are generated
+     * and the legend is disabled. This feature requires
+     * `modules/parallel-coordinates.js`.
+     *
+     * @sample {highcharts} /highcharts/demo/parallel-coordinates/
+     *         Parallel coordinates demo
+     * @sample {highcharts} highcharts/parallel-coordinates/polar/
+     *         Star plot, multivariate data in a polar chart
+     *
+     * @since   6.0.0
+     * @product highcharts
+     */
+    parallelCoordinates: false,
+    /**
+     * Common options for all yAxes rendered in a parallel coordinates plot.
+     * This feature requires `modules/parallel-coordinates.js`.
+     *
+     * The default options are:
+     * <pre>
+     * parallelAxes: {
+     *    lineWidth: 1,       // classic mode only
+     *    gridlinesWidth: 0,  // classic mode only
+     *    title: {
+     *        text: '',
+     *        reserveSpace: false
+     *    },
+     *    labels: {
+     *        x: 0,
+     *        y: 0,
+     *        align: 'center',
+     *        reserveSpace: false
+     *    },
+     *    offset: 0
+     * }</pre>
+     *
+     * @sample {highcharts} highcharts/parallel-coordinates/parallelaxes/
+     *         Set the same tickAmount for all yAxes
+     *
+     * @extends   yAxis
+     * @since     6.0.0
+     * @product   highcharts
+     * @excluding alternateGridColor, breaks, id, gridLineColor,
+     *            gridLineDashStyle, gridLineWidth, minorGridLineColor,
+     *            minorGridLineDashStyle, minorGridLineWidth, plotBands,
+     *            plotLines, angle, gridLineInterpolation, maxColor, maxZoom,
+     *            minColor, scrollbar, stackLabels, stops
+     */
+    parallelAxes: {
+        lineWidth: 1,
+        /**
+         * Titles for yAxes are taken from
+         * [xAxis.categories](#xAxis.categories). All options for `xAxis.labels`
+         * applies to parallel coordinates titles. For example, to style
+         * categories, use [xAxis.labels.style](#xAxis.labels.style).
+         *
+         * @excluding align, enabled, margin, offset, position3d, reserveSpace,
+         *            rotation, skew3d, style, text, useHTML, x, y
+         */
+        title: {
+            text: '',
+            reserveSpace: false
+        },
+        labels: {
+            x: 0,
+            y: 4,
+            align: 'center',
+            reserveSpace: false
+        },
+        offset: 0
+    }
+};
+
+H.setOptions({
+    chart: defaultParallelOptions
+});
+
+// Initialize parallelCoordinates
+addEvent(Chart, 'init', function (e) {
+    var options = e.args[0],
+        defaultyAxis = splat(options.yAxis || {}),
+        yAxisLength = defaultyAxis.length,
+        newYAxes = [];
+
+    /**
+     * Flag used in parallel coordinates plot to check if chart has ||-coords
+     * (parallel coords).
+     *
+     * @requires module:modules/parallel-coordinates
+     *
+     * @name Highcharts.Chart#hasParallelCoordinates
+     * @type {boolean}
+     */
+    this.hasParallelCoordinates = options.chart &&
+        options.chart.parallelCoordinates;
+
+    if (this.hasParallelCoordinates) {
+
+        this.setParallelInfo(options);
+
+        // Push empty yAxes in case user did not define them:
+        for (; yAxisLength <= this.parallelInfo.counter; yAxisLength++) {
+            newYAxes.push({});
+        }
+
+        if (!options.legend) {
+            options.legend = {};
+        }
+        if (options.legend.enabled === undefined) {
+            options.legend.enabled = false;
+        }
+        merge(
+            true,
+            options,
+            // Disable boost
+            {
+                boost: {
+                    seriesThreshold: Number.MAX_VALUE
+                },
+                plotOptions: {
+                    series: {
+                        boostThreshold: Number.MAX_VALUE
+                    }
+                }
+            }
+        );
+
+        options.yAxis = defaultyAxis.concat(newYAxes);
+        options.xAxis = merge(
+            defaultXAxisOptions, // docs
+            splat(options.xAxis || {})[0]
+        );
+    }
+});
+
+// Initialize parallelCoordinates
+addEvent(Chart, 'update', function (e) {
+    var options = e.options;
+
+    if (options.chart) {
+        if (defined(options.chart.parallelCoordinates)) {
+            this.hasParallelCoordinates = options.chart.parallelCoordinates;
+        }
+
+        if (this.hasParallelCoordinates && options.chart.parallelAxes) {
+            this.options.chart.parallelAxes = merge(
+                this.options.chart.parallelAxes,
+                options.chart.parallelAxes
+            );
+            this.yAxis.forEach(function (axis) {
+                axis.update({}, false);
+            });
+        }
+    }
+});
+
+extend(ChartProto, /** @lends Highcharts.Chart.prototype */ {
+    /**
+     * Define how many parellel axes we have according to the longest dataset.
+     * This is quite heavy - loop over all series and check series.data.length
+     * Consider:
+     *
+     * - make this an option, so user needs to set this to get better
+     *   performance
+     *
+     * - check only first series for number of points and assume the rest is the
+     *   same
+     *
+     * @private
+     * @function Highcharts.Chart#setParallelInfo
+     *
+     * @param {Highcharts.Options} options
+     *        User options
+     */
+    setParallelInfo: function (options) {
+        var chart = this,
+            seriesOptions = options.series;
+
+        chart.parallelInfo = {
+            counter: 0
+        };
+
+        seriesOptions.forEach(function (series) {
+            if (series.data) {
+                chart.parallelInfo.counter = Math.max(
+                    chart.parallelInfo.counter,
+                    series.data.length - 1
+                );
+            }
+        });
+    }
+});
+
+
+// On update, keep parallelPosition.
+AxisProto.keepProps.push('parallelPosition');
+
+// Update default options with predefined for a parallel coords.
+addEvent(Axis, 'afterSetOptions', function (e) {
+    var axis = this,
+        chart = axis.chart,
+        axisPosition = ['left', 'width', 'height', 'top'];
+
+    if (chart.hasParallelCoordinates) {
+        if (chart.inverted) {
+            axisPosition = axisPosition.reverse();
+        }
+
+        if (axis.isXAxis) {
+            axis.options = merge(
+                axis.options,
+                defaultXAxisOptions,
+                e.userOptions
+            );
+        } else {
+            axis.options = merge(
+                axis.options,
+                axis.chart.options.chart.parallelAxes,
+                e.userOptions
+            );
+            axis.parallelPosition = pick(
+                axis.parallelPosition,
+                chart.yAxis.length
+            );
+            axis.setParallelPosition(axisPosition, axis.options);
+        }
+    }
+});
+
+
+/* Each axis should gather extremes from points on a particular position in
+   series.data. Not like the default one, which gathers extremes from all series
+   bind to this axis. Consider using series.points instead of series.yData. */
+addEvent(Axis, 'getSeriesExtremes', function (e) {
+    if (this.chart && this.chart.hasParallelCoordinates && !this.isXAxis) {
+        var index = this.parallelPosition,
+            currentPoints = [];
+
+        this.series.forEach(function (series) {
+            if (series.visible && defined(series.yData[index])) {
+                // We need to use push() beacause of null points
+                currentPoints.push(series.yData[index]);
+            }
+        });
+        this.dataMin = arrayMin(currentPoints);
+        this.dataMax = arrayMax(currentPoints);
+
+        e.preventDefault();
+    }
+});
+
+
+extend(AxisProto, /** @lends Highcharts.Axis.prototype */ {
+    /**
+     * Set predefined left+width and top+height (inverted) for yAxes. This
+     * method modifies options param.
+     *
+     * @function Highcharts.Axis#setParallelPosition
+     *
+     * @param  {Array<string>} axisPosition
+     *         ['left', 'width', 'height', 'top'] or
+     *         ['top', 'height', 'width', 'left'] for an inverted chart.
+     *
+     * @param  {Highcharts.AxisOptions} options
+     *         {@link Highcharts.Axis#options}.
+     */
+    setParallelPosition: function (axisPosition, options) {
+        var fraction = (this.parallelPosition + 0.5) /
+            (this.chart.parallelInfo.counter + 1);
+
+        if (this.chart.polar) {
+            options.angle = 360 * fraction;
+        } else {
+            options[axisPosition[0]] = 100 * fraction + '%';
+            this[axisPosition[1]] = options[axisPosition[1]] = 0;
+
+            // In case of chart.update(inverted), remove old options:
+            this[axisPosition[2]] = options[axisPosition[2]] = null;
+            this[axisPosition[3]] = options[axisPosition[3]] = null;
+        }
+    }
+});
+
+
+// Bind each series to each yAxis. yAxis needs a reference to all series to
+// calculate extremes.
+addEvent(H.Series, 'bindAxes', function (e) {
+    if (this.chart.hasParallelCoordinates) {
+        var series = this;
+
+        this.chart.axes.forEach(function (axis) {
+            series.insert(axis.series);
+            axis.isDirty = true;
+        });
+        series.xAxis = this.chart.xAxis[0];
+        series.yAxis = this.chart.yAxis[0];
+
+        e.preventDefault();
+    }
+});
+
+
+// Translate each point using corresponding yAxis.
+addEvent(H.Series, 'afterTranslate', function () {
+    var series = this,
+        chart = this.chart,
+        points = series.points,
+        dataLength = points && points.length,
+        closestPointRangePx = Number.MAX_VALUE,
+        lastPlotX,
+        point,
+        i;
+
+    if (this.chart.hasParallelCoordinates) {
+        for (i = 0; i < dataLength; i++) {
+            point = points[i];
+            if (defined(point.y)) {
+                if (chart.polar) {
+                    point.plotX = chart.yAxis[i].angleRad || 0;
+                } else if (chart.inverted) {
+                    point.plotX = (
+                        chart.plotHeight -
+                        chart.yAxis[i].top +
+                        chart.plotTop
+                    );
+                } else {
+                    point.plotX = chart.yAxis[i].left - chart.plotLeft;
+                }
+                point.clientX = point.plotX;
+
+                point.plotY = chart.yAxis[i]
+                    .translate(point.y, false, true, null, true);
+
+                if (lastPlotX !== undefined) {
+                    closestPointRangePx = Math.min(
+                        closestPointRangePx,
+                        Math.abs(point.plotX - lastPlotX)
+                    );
+                }
+                lastPlotX = point.plotX;
+                point.isInside = chart.isInsidePlot(
+                    point.plotX,
+                    point.plotY,
+                    chart.inverted
+                );
+            } else {
+                point.isNull = true;
+            }
+        }
+        this.closestPointRangePx = closestPointRangePx;
+    }
+}, { order: 1 });
+
+// On destroy, we need to remove series from each axis.series
+H.addEvent(H.Series, 'destroy', function () {
+    if (this.chart.hasParallelCoordinates) {
+        (this.chart.axes || []).forEach(function (axis) {
+            if (axis && axis.series) {
+                erase(axis.series, this);
+                axis.isDirty = axis.forceRedraw = true;
+            }
+        }, this);
+    }
+});
+
+function addFormattedValue(proceed) {
+    var chart = this.series && this.series.chart,
+        config = proceed.apply(this, Array.prototype.slice.call(arguments, 1)),
+        formattedValue,
+        yAxisOptions,
+        labelFormat,
+        yAxis;
+
+    if (
+        chart &&
+        chart.hasParallelCoordinates &&
+        !defined(config.formattedValue)
+    ) {
+        yAxis = chart.yAxis[this.x];
+        yAxisOptions = yAxis.options;
+
+        labelFormat = pick(
+            /**
+             * Parallel coordinates only. Format that will be used for point.y
+             * and available in [tooltip.pointFormat](#tooltip.pointFormat) as
+             * `{point.formattedValue}`. If not set, `{point.formattedValue}`
+             * will use other options, in this order:
+             *
+             * 1. [yAxis.labels.format](#yAxis.labels.format) will be used if
+             *    set
+             *
+             * 2. If yAxis is a category, then category name will be displayed
+             *
+             * 3. If yAxis is a datetime, then value will use the same format as
+             *    yAxis labels
+             *
+             * 4. If yAxis is linear/logarithmic type, then simple value will be
+             *    used
+             *
+             * @sample {highcharts}
+             *         /highcharts/parallel-coordinates/tooltipvalueformat/
+             *         Different tooltipValueFormats's
+             *
+             * @type      {string}
+             * @default   undefined
+             * @since     6.0.0
+             * @product   highcharts
+             * @apioption yAxis.tooltipValueFormat
+             */
+            yAxisOptions.tooltipValueFormat,
+            yAxisOptions.labels.format
+        );
+
+        if (labelFormat) {
+            formattedValue = H.format(
+                labelFormat,
+                extend(
+                    this,
+                    { value: this.y }
+                ),
+                chart.time
+            );
+        } else if (yAxis.isDatetimeAxis) {
+            formattedValue = chart.time.dateFormat(
+                chart.time.resolveDTLFormat(yAxisOptions.dateTimeLabelFormats[
+                    yAxis.tickPositions.info.unitName
+                ]).main,
+                this.y
+            );
+        } else if (yAxisOptions.categories) {
+            formattedValue = yAxisOptions.categories[this.y];
+        } else {
+            formattedValue = this.y;
+        }
+
+        config.formattedValue = config.point.formattedValue = formattedValue;
+    }
+
+    return config;
+}
+
+['line', 'spline'].forEach(function (seriesName) {
+    wrap(
+        H.seriesTypes[seriesName].prototype.pointClass.prototype,
+        'getLabelConfig',
+        addFormattedValue
+    );
+});