aw-highstock_rails 7.0.3

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

@@ -0,0 +1,191 @@
+'use strict';
+import H from '../../parts/Globals.js';
+import '../../parts/Utilities.js';
+
+var Annotation = H.Annotation,
+    MockPoint = Annotation.MockPoint,
+    ControlPoint = Annotation.ControlPoint;
+
+/**
+ * @class
+ * @extends Annotation
+ * @memberOf Annotation
+ */
+function CrookedLine() {
+    Annotation.apply(this, arguments);
+}
+
+H.extendAnnotation(
+    CrookedLine,
+    null,
+    /** @lends Annotation.CrookedLine# */
+    {
+        /**
+         * Overrides default setter to get axes from typeOptions.
+         */
+        setClipAxes: function () {
+            this.clipXAxis = this.chart.xAxis[this.options.typeOptions.xAxis];
+            this.clipYAxis = this.chart.yAxis[this.options.typeOptions.yAxis];
+        },
+        getPointsOptions: function () {
+            var typeOptions = this.options.typeOptions;
+
+            return typeOptions.points.map(function (pointOptions) {
+                pointOptions.xAxis = typeOptions.xAxis;
+                pointOptions.yAxis = typeOptions.yAxis;
+
+                return pointOptions;
+            });
+        },
+
+        getControlPointsOptions: function () {
+            return this.getPointsOptions();
+        },
+
+        addControlPoints: function () {
+            this.getControlPointsOptions().forEach(
+                function (pointOptions, i) {
+                    var controlPoint = new ControlPoint(
+                        this.chart,
+                        this,
+                        H.merge(
+                            this.options.controlPointOptions,
+                            pointOptions.controlPoint
+                        ),
+                        i
+                    );
+
+                    this.controlPoints.push(controlPoint);
+
+                    pointOptions.controlPoint = controlPoint.options;
+                },
+                this
+            );
+        },
+
+        addShapes: function () {
+            var typeOptions = this.options.typeOptions,
+                shape = this.initShape(
+                    H.merge(typeOptions.line, {
+                        type: 'path',
+                        points: this.points.map(function (point, i) {
+                            return function (target) {
+                                return target.annotation.points[i];
+                            };
+                        })
+                    }),
+                    false
+                );
+
+            typeOptions.line = shape.options;
+        }
+    },
+
+    /**
+     * A crooked line annotation.
+     *
+     * @excluding labels, shapes
+     * @sample highcharts/annotations-advanced/crooked-line/
+     *         Crooked line
+     * @product highstock
+     * @optionparent annotations.crookedLine
+     */
+    {
+        /**
+         * Additional options for an annotation with the type.
+         */
+        typeOptions: {
+            /**
+             * This number defines which xAxis the point is connected to.
+             * It refers to either the axis id or the index of the axis
+             * in the xAxis array.
+             */
+            xAxis: 0,
+            /**
+             * This number defines which yAxis the point is connected to.
+             * It refers to either the axis id or the index of the axis
+             * in the xAxis array.
+             */
+            yAxis: 0,
+
+            /**
+             * @type {Array<Object>}
+             * @apioption annotations.crookedLine.typeOptions.points
+             */
+
+            /**
+             * The x position of the point.
+             * @type {number}
+             * @apioption annotations.crookedLine.typeOptions.points.x
+             */
+
+            /**
+             * The y position of the point.
+             * @type {number}
+             * @apioption annotations.crookedLine.typeOptions.points.y
+             */
+
+            /**
+             * @type {number}
+             * @excluding positioner, events
+             * @apioption annotations.crookedLine.typeOptions.points.controlPoint
+             */
+
+            /**
+             * Line options.
+             *
+             * @type {Object}
+             * @excluding height, point, points, r, type, width
+             */
+            line: {
+                fill: 'none'
+            }
+        },
+
+        /**
+         * @excluding positioner, events
+         */
+        controlPointOptions: {
+            positioner: function (target) {
+                var graphic = this.graphic,
+                    xy = MockPoint.pointToPixels(target.points[this.index]);
+
+                return {
+                    x: xy.x - graphic.width / 2,
+                    y: xy.y - graphic.height / 2
+                };
+            },
+
+            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.translatePoint(
+                            translation.x,
+                            translation.y,
+                            this.index
+                        );
+
+                        // Update options:
+                        target.options.typeOptions.points[this.index].x =
+                            target.points[this.index].x;
+                        target.options.typeOptions.points[this.index].y =
+                            target.points[this.index].y;
+
+                        target.redraw(false);
+                    }
+                }
+            }
+        }
+    }
+);
+
+Annotation.types.crookedLine = CrookedLine;
+
+export default CrookedLine;

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

@@ -0,0 +1,76 @@
+'use strict';
+import H from '../../parts/Globals.js';
+import '../../parts/Utilities.js';
+
+var Annotation = H.Annotation,
+    CrookedLine = Annotation.types.crookedLine;
+
+/**
+ * @class
+ * @extends Annotation.CrookedLine
+ * @memberOf Annotation
+ */
+function ElliottWave() {
+    CrookedLine.apply(this, arguments);
+}
+
+H.extendAnnotation(ElliottWave, CrookedLine,
+    /** Annotation.CrookedLine# */
+    {
+        addLabels: function () {
+            this.getPointsOptions().forEach(function (point, i) {
+                var label = this.initLabel(H.merge(
+                    point.label, {
+                        text: this.options.typeOptions.labels[i],
+                        point: function (target) {
+                            return target.annotation.points[i];
+                        }
+                    }
+                ), false);
+
+                point.label = label.options;
+            }, this);
+        }
+    },
+
+    /**
+     * An elliott wave annotation.
+     *
+     * @extends annotations.crookedLine
+     * @sample highcharts/annotations-advanced/elliott-wave/
+     *         Elliott wave
+     * @product highstock
+     * @optionparent annotations.elliottWave
+     */
+    {
+        typeOptions: {
+            /**
+             * @type {Object}
+             * @extends annotations.crookedLine.labelOptions
+             * @apioption annotations.crookedLine.typeOptions.points.label
+             */
+
+            /**
+             * @ignore
+             */
+            labels: ['(0)', '(A)', '(B)', '(C)', '(D)', '(E)'],
+            line: {
+                strokeWidth: 1
+            }
+        },
+
+        labelOptions: {
+            align: 'center',
+            allowOverlap: true,
+            crop: true,
+            overflow: 'none',
+            type: 'rect',
+            backgroundColor: 'none',
+            borderWidth: 0,
+            y: -5
+        }
+    });
+
+Annotation.types.elliottWave = ElliottWave;
+
+export default ElliottWave;

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

@@ -0,0 +1,247 @@
+'use strict';
+import H from '../../parts/Globals.js';
+import '../../parts/Utilities.js';
+
+var Annotation = H.Annotation,
+    MockPoint = Annotation.MockPoint,
+    Tunnel = Annotation.types.tunnel;
+
+var createPathDGenerator = function (retracementIndex, isBackground) {
+    return function () {
+        var annotation = this.annotation,
+            leftTop = this.anchor(
+                annotation.startRetracements[retracementIndex]
+            ).absolutePosition,
+            rightTop = this.anchor(
+                annotation.endRetracements[retracementIndex]
+            ).absolutePosition,
+            d = [
+                'M',
+                Math.round(leftTop.x),
+                Math.round(leftTop.y),
+                'L',
+                Math.round(rightTop.x),
+                Math.round(rightTop.y)
+            ],
+            rightBottom,
+            leftBottom;
+
+        if (isBackground) {
+            rightBottom = this.anchor(
+                annotation.endRetracements[retracementIndex - 1]
+            ).absolutePosition;
+
+            leftBottom = this.anchor(
+                annotation.startRetracements[retracementIndex - 1]
+            ).absolutePosition;
+
+            d.push(
+                'L',
+                Math.round(rightBottom.x),
+                Math.round(rightBottom.y),
+                'L',
+                Math.round(leftBottom.x),
+                Math.round(leftBottom.y)
+            );
+        }
+
+        return d;
+    };
+};
+
+/**
+ * @class
+ * @extends Annotation.Tunnel
+ * @memberOf Annotation
+ **/
+function Fibonacci() {
+    this.startRetracements = [];
+    this.endRetracements = [];
+
+    Tunnel.apply(this, arguments);
+}
+
+Fibonacci.levels = [0, 0.236, 0.382, 0.5, 0.618, 0.786, 1];
+
+H.extendAnnotation(Fibonacci, Tunnel,
+    /** @lends Annotation.Fibonacci# */
+    {
+        linkPoints: function () {
+            Tunnel.prototype.linkPoints.call(this);
+
+            this.linkRetracementsPoints();
+        },
+
+        linkRetracementsPoints: function () {
+            var points = this.points,
+                startDiff = points[0].y - points[3].y,
+                endDiff = points[1].y - points[2].y,
+                startX = points[0].x,
+                endX = points[1].x;
+
+            Fibonacci.levels.forEach(function (level, i) {
+                var startRetracement = points[0].y - startDiff * level,
+                    endRetracement = points[1].y - endDiff * level;
+
+                this.linkRetracementPoint(
+                    i,
+                    startX,
+                    startRetracement,
+                    this.startRetracements
+                );
+
+                this.linkRetracementPoint(
+                    i,
+                    endX,
+                    endRetracement,
+                    this.endRetracements
+                );
+            }, this);
+        },
+
+        linkRetracementPoint: function (
+            pointIndex,
+            x,
+            y,
+            retracements
+        ) {
+            var point = retracements[pointIndex],
+                typeOptions = this.options.typeOptions;
+
+            if (!point) {
+                retracements[pointIndex] = new MockPoint(
+                    this.chart,
+                    this,
+                    {
+                        x: x,
+                        y: y,
+                        xAxis: typeOptions.xAxis,
+                        yAxis: typeOptions.yAxis
+                    }
+                );
+            } else {
+                point.options.x = x;
+                point.options.y = y;
+
+                point.refresh();
+            }
+        },
+
+        addShapes: function () {
+            Fibonacci.levels.forEach(function (level, i) {
+                this.initShape({
+                    type: 'path',
+                    d: createPathDGenerator(i)
+                }, false);
+
+                if (i > 0) {
+                    this.initShape({
+                        type: 'path',
+                        fill: this.options.typeOptions.backgroundColors[i - 1],
+                        strokeWidth: 0,
+                        d: createPathDGenerator(i, true)
+                    });
+                }
+            }, this);
+        },
+
+        addLabels: function () {
+            Fibonacci.levels.forEach(function (level, i) {
+                var options = this.options.typeOptions,
+                    label = this.initLabel(
+                        H.merge(options.labels[i], {
+                            point: function (target) {
+                                var point = MockPoint.pointToOptions(
+                                    target.annotation.startRetracements[i]
+                                );
+
+                                return point;
+                            },
+                            text: level.toString()
+                        })
+                    );
+
+                options.labels[i] = label.options;
+            }, this);
+        }
+    },
+
+    /**
+     * A fibonacci annotation.
+     *
+     * @extends annotations.crookedLine
+     * @sample highcharts/annotations-advanced/fibonacci/
+     *         Fibonacci
+     *
+     * @product highstock
+     * @optionparent annotations.fibonacci
+     */
+    {
+        typeOptions: {
+            /**
+             * The height of the fibonacci in terms of yAxis.
+             */
+            height: 2,
+
+            /**
+             * An array of background colors:
+             * Default to:
+             * <pre>
+[
+  'rgba(130, 170, 255, 0.4)',
+  'rgba(139, 191, 216, 0.4)',
+  'rgba(150, 216, 192, 0.4)',
+  'rgba(156, 229, 161, 0.4)',
+  'rgba(162, 241, 130, 0.4)',
+  'rgba(169, 255, 101, 0.4)'
+]
+              </pre>
+             */
+            backgroundColors: [
+                'rgba(130, 170, 255, 0.4)',
+                'rgba(139, 191, 216, 0.4)',
+                'rgba(150, 216, 192, 0.4)',
+                'rgba(156, 229, 161, 0.4)',
+                'rgba(162, 241, 130, 0.4)',
+                'rgba(169, 255, 101, 0.4)'
+            ],
+
+            /**
+             * The color of line.
+             */
+            lineColor: 'grey',
+
+            /**
+             * An array of colors for the lines.
+             */
+            lineColors: [],
+
+            /**
+             * An array with options for the labels.
+             *
+             * @type {Array<Object>}
+             * @extends annotations.crookedLine.labelOptions
+             * @apioption annotations.fibonacci.typeOptions.labels
+             */
+            labels: []
+        },
+
+        labelOptions: {
+            allowOverlap: true,
+            align: 'right',
+            backgroundColor: 'none',
+            borderWidth: 0,
+            crop: false,
+            overflow: 'none',
+            shape: 'rect',
+            style: {
+                color: 'grey'
+            },
+            verticalAlign: 'middle',
+            y: 0
+        }
+    });
+
+Annotation.types.fibonacci = Fibonacci;
+
+export default Fibonacci;