aw-highstock_rails 7.0.3

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

@@ -0,0 +1,425 @@
+/* *
+ *
+ *  License: www.highcharts.com/license
+ *
+ * */
+
+'use strict';
+
+import H from '../parts/Globals.js';
+import '../parts/Utilities.js';
+import requiredIndicatorMixin from '../mixins/indicator-required.js';
+
+var pick = H.pick,
+    error = H.error,
+    Series = H.Series,
+    isArray = H.isArray,
+    addEvent = H.addEvent,
+    seriesType = H.seriesType,
+    seriesTypes = H.seriesTypes,
+    ohlcProto = H.seriesTypes.ohlc.prototype,
+    generateMessage = requiredIndicatorMixin.generateMessage;
+
+/**
+ * The parameter allows setting line series type and use OHLC indicators. Data
+ * in OHLC format is required.
+ *
+ * @sample {highstock} stock/indicators/use-ohlc-data
+ *         Plot line on Y axis
+ *
+ * @type      {boolean}
+ * @product   highstock
+ * @apioption plotOptions.line.useOhlcData
+ */
+
+addEvent(H.Series, 'init', function (eventOptions) {
+    var series = this,
+        options = eventOptions.options;
+
+    if (
+        options.useOhlcData &&
+        options.id !== 'highcharts-navigator-series'
+    ) {
+        H.extend(series, {
+            pointValKey: ohlcProto.pointValKey,
+            keys: ohlcProto.keys,
+            pointArrayMap: ohlcProto.pointArrayMap,
+            toYData: ohlcProto.toYData
+        });
+    }
+});
+
+addEvent(Series, 'afterSetOptions', function (e) {
+    var options = e.options,
+        dataGrouping = options.dataGrouping;
+
+    if (
+        dataGrouping &&
+        options.useOhlcData &&
+        options.id !== 'highcharts-navigator-series'
+    ) {
+        dataGrouping.approximation = 'ohlc';
+    }
+});
+
+/**
+ * The SMA series type.
+ *
+ * @private
+ * @class
+ * @name Highcharts.seriesTypes.sma
+ *
+ * @augments Highcharts.Series
+ */
+seriesType(
+    'sma',
+    'line',
+    /**
+     * Simple moving average indicator (SMA). This series requires `linkedTo`
+     * option to be set.
+     *
+     * @sample stock/indicators/sma
+     *         Simple moving average indicator
+     *
+     * @extends      plotOptions.line
+     * @since        6.0.0
+     * @excluding    allAreas, colorAxis, joinBy, keys, navigatorOptions,
+     *               pointInterval, pointIntervalUnit, pointPlacement,
+     *               pointRange, pointStart, showInNavigator, stacking,
+     *               useOhlcData
+     * @product      highstock
+     * @optionparent plotOptions.sma
+     */
+    {
+        /**
+         * The name of the series as shown in the legend, tooltip etc. If not
+         * set, it will be based on a technical indicator type and default
+         * params.
+         *
+         * @type {string}
+         */
+        name: undefined,
+        tooltip: {
+            /**
+             * Number of decimals in indicator series.
+             */
+            valueDecimals: 4
+        },
+        /**
+         * The main series ID that indicator will be based on. Required for this
+         * indicator.
+         *
+         * @type {string}
+         */
+        linkedTo: undefined,
+        /**
+         * Whether to compare indicator to the main series values
+         * or indicator values.
+         *
+         * @sample {highstock} stock/plotoptions/series-comparetomain/
+         *         compareToMain
+         *
+         * @type {boolean}
+         */
+        compareToMain: false,
+        /**
+         * Paramters used in calculation of regression series' points.
+         */
+        params: {
+            /**
+             * The point index which indicator calculations will base. For
+             * example using OHLC data, index=2 means the indicator will be
+             * calculated using Low values.
+             */
+            index: 0,
+            /**
+             * The base period for indicator calculations. This is the number of
+             * data points which are taken into account for the indicator
+             * calculations.
+             */
+            period: 14
+        }
+    },
+    /**
+     * @lends Highcharts.Series.prototype
+     */
+    {
+        processData: function () {
+            var series = this,
+                compareToMain = series.options.compareToMain,
+                linkedParent = series.linkedParent;
+
+            Series.prototype.processData.apply(series, arguments);
+
+            if (linkedParent && linkedParent.compareValue && compareToMain) {
+                series.compareValue = linkedParent.compareValue;
+            }
+        },
+        bindTo: {
+            series: true,
+            eventName: 'updatedData'
+        },
+        useCommonDataGrouping: true,
+        nameComponents: ['period'],
+        nameSuffixes: [], // e.g. Zig Zag uses extra '%'' in the legend name
+        calculateOn: 'init',
+        // Defines on which other indicators is this indicator based on.
+        requiredIndicators: [],
+        requireIndicators: function () {
+            var obj = {
+                allLoaded: true
+            };
+
+            // Check whether all required indicators are loaded, else return
+            // the object with missing indicator's name.
+            this.requiredIndicators.forEach(function (indicator) {
+                if (seriesTypes[indicator]) {
+                    seriesTypes[indicator].prototype.requireIndicators();
+                } else {
+                    obj.allLoaded = false;
+                    obj.needed = indicator;
+                }
+            });
+            return obj;
+        },
+        init: function (chart, options) {
+            var indicator = this,
+                requiredIndicators = indicator.requireIndicators();
+
+            // Check whether all required indicators are loaded.
+            if (!requiredIndicators.allLoaded) {
+                return error(
+                    generateMessage(indicator.type, requiredIndicators.needed)
+                );
+            }
+
+            Series.prototype.init.call(
+                indicator,
+                chart,
+                options
+            );
+
+            // Make sure we find series which is a base for an indicator
+            chart.linkSeries();
+
+            indicator.dataEventsToUnbind = [];
+
+            function recalculateValues() {
+                var oldData = indicator.points || [],
+                    oldDataLength = (indicator.xData || []).length,
+                    processedData = indicator.getValues(
+                        indicator.linkedParent,
+                        indicator.options.params
+                    ) || {
+                        values: [],
+                        xData: [],
+                        yData: []
+                    },
+                    croppedDataValues = [],
+                    overwriteData = true,
+                    oldFirstPointIndex,
+                    oldLastPointIndex,
+                    croppedData,
+                    min,
+                    max,
+                    i;
+
+                // We need to update points to reflect changes in all,
+                // x and y's, values. However, do it only for non-grouped
+                // data - grouping does it for us (#8572)
+                if (
+                    oldDataLength &&
+                    !indicator.hasGroupedData &&
+                    indicator.visible &&
+                    indicator.points
+                ) {
+                    // When data is cropped update only avaliable points (#9493)
+                    if (indicator.cropped) {
+                        if (indicator.xAxis) {
+                            min = indicator.xAxis.min;
+                            max = indicator.xAxis.max;
+                        }
+
+                        croppedData = indicator.cropData(
+                            processedData.xData,
+                            processedData.yData,
+                            min,
+                            max
+                        );
+
+                        for (i = 0; i < croppedData.xData.length; i++) {
+                            croppedDataValues.push([
+                                croppedData.xData[i],
+                                croppedData.yData[i]
+                            ]);
+                        }
+
+                        oldFirstPointIndex = processedData.xData.indexOf(
+                            indicator.xData[0]
+                        );
+                        oldLastPointIndex = processedData.xData.indexOf(
+                            indicator.xData[indicator.xData.length - 1]
+                        );
+
+                        // Check if indicator points should be shifted (#8572)
+                        if (
+                            oldFirstPointIndex === -1 &&
+                            oldLastPointIndex === processedData.xData.length - 2
+                        ) {
+                            if (croppedDataValues[0][0] === oldData[0].x) {
+                                croppedDataValues.shift();
+                            }
+                        }
+
+                        indicator.updateData(croppedDataValues);
+
+                    // Omit addPoint() and removePoint() cases
+                    } else if (
+                        processedData.xData.length !== oldDataLength - 1 &&
+                        processedData.xData.length !== oldDataLength + 1
+                    ) {
+                        overwriteData = false;
+                        indicator.updateData(processedData.values);
+                    }
+                }
+
+                if (overwriteData) {
+                    indicator.xData = processedData.xData;
+                    indicator.yData = processedData.yData;
+                    indicator.options.data = processedData.values;
+                }
+
+                // Removal of processedXData property is required because on
+                // first translate processedXData array is empty
+                if (indicator.bindTo.series === false) {
+                    delete indicator.processedXData;
+
+                    indicator.isDirty = true;
+                    indicator.redraw();
+                }
+                indicator.isDirtyData = false;
+            }
+
+            if (!indicator.linkedParent) {
+                return error(
+                    'Series ' +
+                    indicator.options.linkedTo +
+                    ' not found! Check `linkedTo`.',
+                    false,
+                    chart
+                );
+            }
+
+            indicator.dataEventsToUnbind.push(
+                addEvent(
+                    indicator.bindTo.series ?
+                        indicator.linkedParent : indicator.linkedParent.xAxis,
+                    indicator.bindTo.eventName,
+                    recalculateValues
+                )
+            );
+
+            if (indicator.calculateOn === 'init') {
+                recalculateValues();
+            } else {
+                var unbinder = addEvent(
+                    indicator.chart,
+                    indicator.calculateOn,
+                    function () {
+                        recalculateValues();
+                        // Call this just once, on init
+                        unbinder();
+                    }
+                );
+            }
+
+            return indicator;
+        },
+        getName: function () {
+            var name = this.name,
+                params = [];
+
+            if (!name) {
+
+                (this.nameComponents || []).forEach(
+                    function (component, index) {
+                        params.push(
+                            this.options.params[component] +
+                            pick(this.nameSuffixes[index], '')
+                        );
+                    },
+                    this
+                );
+
+                name = (this.nameBase || this.type.toUpperCase()) +
+                    (this.nameComponents ? ' (' + params.join(', ') + ')' : '');
+            }
+
+            return name;
+        },
+        getValues: function (series, params) {
+            var period = params.period,
+                xVal = series.xData,
+                yVal = series.yData,
+                yValLen = yVal.length,
+                range = 0,
+                sum = 0,
+                SMA = [],
+                xData = [],
+                yData = [],
+                index = -1,
+                i,
+                SMAPoint;
+
+            if (xVal.length < period) {
+                return false;
+            }
+
+            // Switch index for OHLC / Candlestick / Arearange
+            if (isArray(yVal[0])) {
+                index = params.index ? params.index : 0;
+            }
+
+            // Accumulate first N-points
+            while (range < period - 1) {
+                sum += index < 0 ? yVal[range] : yVal[range][index];
+                range++;
+            }
+
+            // Calculate value one-by-one for each period in visible data
+            for (i = range; i < yValLen; i++) {
+                sum += index < 0 ? yVal[i] : yVal[i][index];
+
+                SMAPoint = [xVal[i], sum / period];
+                SMA.push(SMAPoint);
+                xData.push(SMAPoint[0]);
+                yData.push(SMAPoint[1]);
+
+                sum -= index < 0 ? yVal[i - range] : yVal[i - range][index];
+            }
+
+            return {
+                values: SMA,
+                xData: xData,
+                yData: yData
+            };
+        },
+        destroy: function () {
+            this.dataEventsToUnbind.forEach(function (unbinder) {
+                unbinder();
+            });
+            Series.prototype.destroy.call(this);
+        }
+    }
+);
+
+/**
+ * A `SMA` series. If the [type](#series.sma.type) option is not specified, it
+ * is inherited from [chart.type](#chart.type).
+ *
+ * @extends   series,plotOptions.sma
+ * @since     6.0.0
+ * @product   highstock
+ * @excluding dataParser, dataURL, useOhlcData
+ * @apioption series.sma
+ */

data/vendor/assets/javascripts/highstock/es-modules/indicators/keltner-channels.src.js

@@ -0,0 +1,193 @@
+/* *
+ *
+ *  License: www.highcharts.com/license
+ *
+ * */
+
+'use strict';
+
+import H from '../parts/Globals.js';
+import '../parts/Utilities.js';
+import multipleLinesMixin from '../mixins/multipe-lines.js';
+
+var SMA = H.seriesTypes.sma,
+    EMA = H.seriesTypes.ema,
+    ATR = H.seriesTypes.atr,
+    merge = H.merge,
+    correctFloat = H.correctFloat;
+
+/**
+ * The Keltner Channels series type.
+ *
+ * @private
+ * @class
+ * @name Highcharts.seriesTypes.keltnerchannels
+ *
+ * @augments Highcharts.Series
+ */
+H.seriesType(
+    'keltnerchannels',
+    'sma',
+    /**
+     * Keltner Channels. This series requires the `linkedTo` option to be set
+     * and should be loaded after the `stock/indicators/indicators.js`,
+     * `stock/indicators/atr.js`, and `stock/ema/.js`.
+     *
+     * @sample {highstock} stock/indicators/keltner-channels
+     *         Keltner Channels
+     *
+     * @extends      plotOptions.sma
+     * @since        7.0.0
+     * @product      highstock
+     * @excluding    allAreas, colorAxis, compare, compareBase, joinBy, keys,
+     *               navigatorOptions, pointInterval, pointIntervalUnit,
+     *               pointPlacement, pointRange, pointStart,showInNavigator,
+     *               stacking
+     * @optionparent plotOptions.keltnerchannels
+     */
+    {
+        params: {
+            period: 20,
+            /**
+             * The ATR period.
+             */
+            periodATR: 10,
+            /**
+             * The ATR multiplier.
+             */
+            multiplierATR: 2
+        },
+        /**
+         * Bottom line options.
+         *
+         */
+        bottomLine: {
+            /**
+             * Styles for a bottom line.
+             *
+             */
+            styles: {
+                /**
+                 * Pixel width of the line.
+                 */
+                lineWidth: 1,
+                /**
+                 * Color of the line. If not set, it's inherited from
+                 * `plotOptions.keltnerchannels.color`
+                 */
+                lineColor: undefined
+            }
+        },
+        /**
+         * Top line options.
+         *
+         * @extends plotOptions.keltnerchannels.bottomLine
+         */
+        topLine: {
+            styles: {
+                lineWidth: 1,
+                lineColor: undefined
+            }
+        },
+        tooltip: {
+            pointFormat: '<span style="color:{point.color}">\u25CF</span><b> {series.name}</b><br/>Upper Channel: {point.top}<br/>EMA({series.options.params.period}): {point.middle}<br/>Lower Channel: {point.bottom}<br/>'
+        },
+        marker: {
+            enabled: false
+        },
+        dataGrouping: {
+            approximation: 'averages'
+        },
+        lineWidth: 1
+    },
+    /**
+     * @lends Highcharts.Series#
+     */
+    merge(multipleLinesMixin, {
+        pointArrayMap: ['top', 'middle', 'bottom'],
+        pointValKey: 'middle',
+        nameBase: 'Keltner Channels',
+        nameComponents: ['period', 'periodATR', 'multiplierATR'],
+        linesApiNames: ['topLine', 'bottomLine'],
+        requiredIndicators: ['ema', 'atr'],
+        init: function () {
+            SMA.prototype.init.apply(this, arguments);
+            // Set default color for lines:
+            this.options = merge({
+                topLine: {
+                    styles: {
+                        lineColor: this.color
+                    }
+                },
+                bottomLine: {
+                    styles: {
+                        lineColor: this.color
+                    }
+                }
+            }, this.options);
+        },
+        getValues: function (series, params) {
+            var period = params.period,
+                periodATR = params.periodATR,
+                multiplierATR = params.multiplierATR,
+                index = params.index,
+                yVal = series.yData,
+                yValLen = yVal ? yVal.length : 0,
+                // Keltner Channels array structure:
+                // 0-date, 1-top line, 2-middle line, 3-bottom line
+                KC = [],
+                ML, TL, BL, // middle line, top line and bottom line
+                date,
+                seriesEMA = EMA.prototype.getValues(series,
+                    {
+                        period: period,
+                        index: index
+                    }),
+                seriesATR = ATR.prototype.getValues(series,
+                    {
+                        period: periodATR
+                    }),
+                pointEMA,
+                pointATR,
+                xData = [],
+                yData = [],
+                i;
+
+            if (yValLen < period) {
+                return false;
+            }
+
+            for (i = period; i <= yValLen; i++) {
+                pointEMA = seriesEMA.values[i - period];
+                pointATR = seriesATR.values[i - periodATR];
+                date = pointEMA[0];
+                TL = correctFloat(pointEMA[1] + (multiplierATR * pointATR[1]));
+                BL = correctFloat(pointEMA[1] - (multiplierATR * pointATR[1]));
+                ML = pointEMA[1];
+                KC.push([date, TL, ML, BL]);
+                xData.push(date);
+                yData.push([TL, ML, BL]);
+            }
+
+            return {
+                values: KC,
+                xData: xData,
+                yData: yData
+            };
+        }
+    })
+);
+
+/**
+ * A Keltner Channels indicator. If the [type](#series.keltnerchannels.type)
+ * option is not specified, it is inherited from[chart.type](#chart.type).
+ *
+ * @extends      series,plotOptions.keltnerchannels
+ * @since        7.0.0
+ * @product      highstock
+ * @excluding    allAreas, colorAxis, compare, compareBase, dataParser, dataURL,
+ *               joinBy, keys, navigatorOptions, pointInterval,
+ *               pointIntervalUnit, pointPlacement, pointRange, pointStart,
+ *               stacking, showInNavigator
+ * @optionparent series.keltnerchannels
+ */