aw-highstock_rails 7.0.3

data/vendor/assets/javascripts/highstock/es-modules/annotations/types/Pitchfork.js

@@ -0,0 +1,203 @@
+'use strict';
+import H from '../../parts/Globals.js';
+import '../../parts/Utilities.js';
+
+var Annotation = H.Annotation,
+    MockPoint = Annotation.MockPoint,
+    InfinityLine = Annotation.types.infinityLine;
+
+/**
+ * @class
+ * @extends Highcharts.InfinityLine
+ * @memberOf Highcharts
+ **/
+function Pitchfork() {
+    InfinityLine.apply(this, arguments);
+}
+
+Pitchfork.findEdgePoint = function (
+    point,
+    firstAnglePoint,
+    secondAnglePoint
+) {
+    var angle = Math.atan2(
+            secondAnglePoint.plotY - firstAnglePoint.plotY,
+            secondAnglePoint.plotX - firstAnglePoint.plotX
+        ),
+        distance = 1e7;
+
+    return {
+        x: point.plotX + distance * Math.cos(angle),
+        y: point.plotY + distance * Math.sin(angle)
+    };
+};
+
+Pitchfork.middleLineEdgePoint = function (target) {
+    var annotation = target.annotation,
+        points = annotation.points;
+
+    return InfinityLine.findEdgePoint(
+        points[0],
+        new MockPoint(
+            annotation.chart,
+            target,
+            annotation.midPointOptions()
+        )
+    );
+};
+
+var outerLineEdgePoint = function (firstPointIndex) {
+    return function (target) {
+        var annotation = target.annotation,
+            points = annotation.points;
+
+        return Pitchfork.findEdgePoint(
+            points[firstPointIndex],
+            points[0],
+            new MockPoint(
+                annotation.chart,
+                target,
+                annotation.midPointOptions()
+            )
+        );
+    };
+};
+
+Pitchfork.topLineEdgePoint = outerLineEdgePoint(1);
+Pitchfork.bottomLineEdgePoint = outerLineEdgePoint(0);
+
+H.extendAnnotation(Pitchfork, InfinityLine,
+    {
+        midPointOptions: function () {
+            var points = this.points;
+
+            return {
+                x: (points[1].x + points[2].x) / 2,
+                y: (points[1].y + points[2].y) / 2,
+                xAxis: points[0].series.xAxis,
+                yAxis: points[0].series.yAxis
+            };
+        },
+
+        addShapes: function () {
+            this.addLines();
+            this.addBackgrounds();
+        },
+
+        addLines: function () {
+            this.initShape({
+                type: 'path',
+                points: [
+                    this.points[0],
+                    Pitchfork.middleLineEdgePoint
+                ]
+            }, false);
+
+            this.initShape({
+                type: 'path',
+                points: [
+                    this.points[1],
+                    Pitchfork.topLineEdgePoint
+                ]
+            }, false);
+
+            this.initShape({
+                type: 'path',
+                points: [
+                    this.points[2],
+                    Pitchfork.bottomLineEdgePoint
+                ]
+            }, false);
+        },
+
+        addBackgrounds: function () {
+            var shapes = this.shapes,
+                typeOptions = this.options.typeOptions;
+
+            var innerBackground = this.initShape(
+                H.merge(typeOptions.innerBackground, {
+                    type: 'path',
+                    points: [
+                        function (target) {
+                            var annotation = target.annotation,
+                                points = annotation.points,
+                                midPointOptions = annotation.midPointOptions();
+
+                            return {
+                                x: (points[1].x + midPointOptions.x) / 2,
+                                y: (points[1].y + midPointOptions.y) / 2,
+                                xAxis: midPointOptions.xAxis,
+                                yAxis: midPointOptions.yAxis
+                            };
+                        },
+                        shapes[1].points[1],
+                        shapes[2].points[1],
+                        function (target) {
+                            var annotation = target.annotation,
+                                points = annotation.points,
+                                midPointOptions = annotation.midPointOptions();
+
+                            return {
+                                x: (midPointOptions.x + points[2].x) / 2,
+                                y: (midPointOptions.y + points[2].y) / 2,
+                                xAxis: midPointOptions.xAxis,
+                                yAxis: midPointOptions.yAxis
+                            };
+                        }
+                    ]
+                })
+            );
+
+            var outerBackground = this.initShape(
+                H.merge(typeOptions.outerBackground, {
+                    type: 'path',
+                    points: [
+                        this.points[1],
+                        shapes[1].points[1],
+                        shapes[2].points[1],
+                        this.points[2]
+                    ]
+                })
+            );
+
+            typeOptions.innerBackground = innerBackground.options;
+            typeOptions.outerBackground = outerBackground.options;
+        }
+    },
+    /**
+     * A pitchfork annotation.
+     *
+     * @extends annotations.infinityLine
+     * @sample highcharts/annotations-advanced/pitchfork/
+     *         Pitchfork
+     * @product highstock
+     * @optionparent annotations.pitchfork
+     */
+    {
+        typeOptions: {
+            /**
+             * Inner background options.
+             *
+             * @extends annotations.crookedLine.shapeOptions
+             * @excluding height, r, type, width
+             */
+            innerBackground: {
+                fill: 'rgba(130, 170, 255, 0.4)',
+                strokeWidth: 0
+            },
+            /**
+             * Outer background options.
+             *
+             * @extends annotations.crookedLine.shapeOptions
+             * @excluding height, r, type, width
+             */
+            outerBackground: {
+                fill: 'rgba(156, 229, 161, 0.4)',
+                strokeWidth: 0
+            }
+        }
+    });
+
+Annotation.types.pitchfork = Pitchfork;
+
+export default Pitchfork;

data/vendor/assets/javascripts/highstock/es-modules/annotations/types/Tunnel.js

@@ -0,0 +1,242 @@
+'use strict';
+import H from '../../parts/Globals.js';
+import '../../parts/Utilities.js';
+
+var Annotation = H.Annotation,
+    CrookedLine = Annotation.types.crookedLine,
+    ControlPoint = Annotation.ControlPoint,
+    MockPoint = Annotation.MockPoint;
+
+function getSecondCoordinate(p1, p2, x) {
+    return (p2.y - p1.y) / (p2.x - p1.x) * (x - p1.x) + p1.y;
+}
+
+/**
+ * @class
+ * @extends Annotation.CrookedLine
+ * @memberOf Annotation
+ **/
+function Tunnel() {
+    CrookedLine.apply(this, arguments);
+}
+
+H.extendAnnotation(
+    Tunnel,
+    CrookedLine,
+    /** @lends Annotation.Tunnel# */
+    {
+        getPointsOptions: function () {
+            var pointsOptions =
+                CrookedLine.prototype.getPointsOptions.call(this);
+
+            pointsOptions[2] = this.heightPointOptions(pointsOptions[1]);
+            pointsOptions[3] = this.heightPointOptions(pointsOptions[0]);
+
+            return pointsOptions;
+        },
+
+        getControlPointsOptions: function () {
+            return this.getPointsOptions().slice(0, 2);
+        },
+
+        heightPointOptions: function (pointOptions) {
+            var heightPointOptions = H.merge(pointOptions);
+
+            heightPointOptions.y += this.options.typeOptions.height;
+
+            return heightPointOptions;
+        },
+
+        addControlPoints: function () {
+            CrookedLine.prototype.addControlPoints.call(this);
+
+            var options = this.options,
+                controlPoint = new ControlPoint(
+                    this.chart,
+                    this,
+                    H.merge(
+                        options.controlPointOptions,
+                        options.typeOptions.heightControlPoint
+                    ),
+                    2
+                );
+
+            this.controlPoints.push(controlPoint);
+
+            options.typeOptions.heightControlPoint = controlPoint.options;
+        },
+
+        addShapes: function () {
+            this.addLine();
+            this.addBackground();
+        },
+
+        addLine: function () {
+            var line = this.initShape(
+                H.merge(this.options.typeOptions.line, {
+                    type: 'path',
+                    points: [
+                        this.points[0],
+                        this.points[1],
+                        function (target) {
+                            var pointOptions = MockPoint.pointToOptions(
+                                target.annotation.points[2]
+                            );
+
+                            pointOptions.command = 'M';
+
+                            return pointOptions;
+                        },
+                        this.points[3]
+                    ]
+                }),
+                false
+            );
+
+            this.options.typeOptions.line = line.options;
+        },
+
+        addBackground: function () {
+            var background = this.initShape(H.merge(
+                this.options.typeOptions.background,
+                {
+                    type: 'path',
+                    points: this.points.slice()
+                }
+            ));
+
+            this.options.typeOptions.background = background.options;
+        },
+
+        /**
+         * Translate start or end ("left" or "right") side of the tunnel.
+         *
+         * @param {number} dx - the amount of x translation
+         * @param {number} dy - the amount of y translation
+         * @param {boolean} [end] - whether to translate start or end side
+         */
+        translateSide: function (dx, dy, end) {
+            var topIndex = Number(end),
+                bottomIndex = topIndex === 0 ? 3 : 2;
+
+            this.translatePoint(dx, dy, topIndex);
+            this.translatePoint(dx, dy, bottomIndex);
+        },
+
+        /**
+         * Translate height of the tunnel.
+         *
+         * @param {number} dh - the amount of height translation
+         */
+        translateHeight: function (dh) {
+            this.translatePoint(0, dh, 2);
+            this.translatePoint(0, dh, 3);
+
+            this.options.typeOptions.height =
+                this.points[3].y - this.points[0].y;
+        }
+    },
+
+    /**
+     * A tunnel annotation.
+     *
+     * @extends annotations.crookedLine
+     * @sample highcharts/annotations-advanced/tunnel/
+     *         Tunnel
+     * @product highstock
+     * @optionparent annotations.tunnel
+     */
+    {
+        typeOptions: {
+            xAxis: 0,
+            yAxis: 0,
+            /**
+             * Background options.
+             *
+             * @type {Object}
+             * @excluding height, point, points, r, type, width, markerEnd,
+             *            markerStart
+             */
+            background: {
+                fill: 'rgba(130, 170, 255, 0.4)',
+                strokeWidth: 0
+            },
+            line: {
+                strokeWidth: 1
+            },
+            /**
+             * The height of the annotation in terms of yAxis.
+             */
+            height: -2,
+
+
+            /**
+             * Options for the control point which controls
+             * the annotation's height.
+             *
+             * @extends annotations.crookedLine.controlPointOptions
+             * @excluding positioner, events
+             */
+            heightControlPoint: {
+                positioner: function (target) {
+                    var startXY = MockPoint.pointToPixels(target.points[2]),
+                        endXY = MockPoint.pointToPixels(target.points[3]),
+                        x = (startXY.x + endXY.x) / 2;
+
+                    return {
+                        x: x - this.graphic.width / 2,
+                        y: getSecondCoordinate(startXY, endXY, x) -
+                        this.graphic.height / 2
+                    };
+                },
+                events: {
+                    drag: function (e, target) {
+                        if (
+                            target.chart.isInsidePlot(
+                                e.chartX - target.chart.plotLeft,
+                                e.chartY - target.chart.plotTop
+                            )
+                        ) {
+                            target.translateHeight(
+                                this.mouseMoveToTranslation(e).y
+                            );
+
+                            target.redraw(false);
+                        }
+                    }
+                }
+            }
+        },
+
+        /**
+         * @extends annotations.crookedLine.controlPointOptions
+         * @excluding positioner, events
+         */
+        controlPointOptions: {
+            events: {
+                drag: function (e, target) {
+                    if (
+                        target.chart.isInsidePlot(
+                            e.chartX - target.chart.plotLeft,
+                            e.chartY - target.chart.plotTop
+                        )
+                    ) {
+                        var translation = this.mouseMoveToTranslation(e);
+
+                        target.translateSide(
+                            translation.x,
+                            translation.y,
+                            this.index
+                        );
+
+                        target.redraw(false);
+                    }
+                }
+            }
+        }
+    }
+);
+
+Annotation.types.tunnel = Tunnel;
+
+export default Tunnel;

data/vendor/assets/javascripts/highstock/es-modules/annotations/types/VerticalLine.js

@@ -0,0 +1,157 @@
+'use strict';
+import H from '../../parts/Globals.js';
+import '../../parts/Utilities.js';
+
+var Annotation = H.Annotation,
+    MockPoint = Annotation.MockPoint;
+
+/**
+ * @class
+ * @extends Annotation
+ * @memberOf Highcharts
+ **/
+function VerticalLine() {
+    H.Annotation.apply(this, arguments);
+}
+
+VerticalLine.connectorFirstPoint = function (target) {
+    var annotation = target.annotation,
+        point = annotation.points[0],
+        xy = MockPoint.pointToPixels(point, true),
+        y = xy.y,
+        offset = annotation.options.typeOptions.label.offset;
+
+    if (annotation.chart.inverted) {
+        y = xy.x;
+    }
+
+    return {
+        x: point.x,
+        xAxis: point.series.xAxis,
+        y: y + offset
+    };
+};
+
+VerticalLine.connectorSecondPoint = function (target) {
+    var annotation = target.annotation,
+        typeOptions = annotation.options.typeOptions,
+        point = annotation.points[0],
+        yOffset = typeOptions.yOffset,
+        xy = MockPoint.pointToPixels(point, true),
+        y = xy[annotation.chart.inverted ? 'x' : 'y'];
+
+    if (typeOptions.label.offset < 0) {
+        yOffset *= -1;
+    }
+
+    return {
+        x: point.x,
+        xAxis: point.series.xAxis,
+        y: y + yOffset
+    };
+};
+
+H.extendAnnotation(VerticalLine, null,
+
+    /** @lends Annotation.VerticalLine# */
+    {
+        getPointsOptions: function () {
+            return [this.options.typeOptions.point];
+        },
+
+        addShapes: function () {
+            var typeOptions = this.options.typeOptions,
+                connector = this.initShape(
+                    H.merge(typeOptions.connector, {
+                        type: 'path',
+                        points: [
+                            VerticalLine.connectorFirstPoint,
+                            VerticalLine.connectorSecondPoint
+                        ]
+                    }),
+                    false
+                );
+
+            typeOptions.connector = connector.options;
+        },
+
+        addLabels: function () {
+            var typeOptions = this.options.typeOptions,
+                labelOptions = typeOptions.label,
+                x = 0,
+                y = labelOptions.offset,
+                verticalAlign = labelOptions.offset < 0 ? 'bottom' : 'top',
+                align = 'center';
+
+            if (this.chart.inverted) {
+                x = labelOptions.offset;
+                y = 0;
+                verticalAlign = 'middle';
+                align = labelOptions.offset < 0 ? 'right' : 'left';
+            }
+
+            var label = this.initLabel(
+                H.merge(labelOptions, {
+                    verticalAlign: verticalAlign,
+                    align: align,
+                    x: x,
+                    y: y
+                })
+            );
+
+            typeOptions.label = label.options;
+        }
+    },
+
+    /**
+     * A vertical line annotation.
+     *
+     * @extends annotations.crookedLine
+     * @excluding labels, shapes, controlPointOptions
+     * @sample highcharts/annotations-advanced/vertical-line/
+     *         Vertical line
+     * @product highstock
+     * @optionparent annotations.verticalLine
+     */
+    {
+        typeOptions: {
+            /**
+             * @ignore
+             */
+            yOffset: 10,
+
+            /**
+             * Label options.
+             *
+             * @extends annotations.crookedLine.labelOptions
+             */
+            label: {
+                offset: -40,
+                point: function (target) {
+                    return target.annotation.points[0];
+                },
+                allowOverlap: true,
+                backgroundColor: 'none',
+                borderWidth: 0,
+                crop: true,
+                overflow: 'none',
+                shape: 'rect',
+                text: '{y:.2f}'
+            },
+
+            /**
+             * Connector options.
+             *
+             * @extends annotations.crookedLine.shapeOptions
+             * @excluding height, r, type, width
+             */
+            connector: {
+                strokeWidth: 1,
+                markerEnd: 'arrow'
+            }
+        }
+    });
+
+Annotation.types.verticalLine = VerticalLine;
+
+export default VerticalLine;