highcharts 9.2.2 → 9.3.3

package/es-modules/Stock/Indicators/MultipleLinesComposition.js

@@ -0,0 +1,294 @@
+/**
+ *
+ *  (c) 2010-2021 Wojciech Chmiel
+ *
+ *  License: www.highcharts.com/license
+ *
+ *  !!!!!!! SOURCE GETS TRANSPILED BY TYPESCRIPT. EDIT TS FILE ONLY. !!!!!!!
+ *
+ * */
+'use strict';
+import SeriesRegistry from '../../Core/Series/SeriesRegistry.js';
+var SMAIndicator = SeriesRegistry.seriesTypes.sma;
+import U from '../../Core/Utilities.js';
+var defined = U.defined, error = U.error, merge = U.merge;
+/* *
+ *
+ *  Composition
+ *
+ * */
+/**
+ * Composition useful for all indicators that have more than one line. Compose
+ * it with your implementation where you will provide the `getValues` method
+ * appropriate to your indicator and `pointArrayMap`, `pointValKey`,
+ * `linesApiNames` properties. Notice that `pointArrayMap` should be consistent
+ * with the amount of lines calculated in the `getValues` method.
+ *
+ * @private
+ * @mixin multipleLinesMixin
+ */
+var MultipleLinesComposition;
+(function (MultipleLinesComposition) {
+    /* *
+     *
+     *  Declarations
+     *
+     * */
+    /* *
+     *
+     *  Constants
+     *
+     * */
+    var composedClasses = [];
+    /**
+     * Additional lines DOCS names. Elements of linesApiNames array should
+     * be consistent with DOCS line names defined in your implementation.
+     * Notice that linesApiNames should have decreased amount of elements
+     * relative to pointArrayMap (without pointValKey).
+     *
+     * @private
+     * @name multipleLinesMixin.linesApiNames
+     * @type {Array<string>}
+     */
+    var linesApiNames = ['bottomLine'];
+    /**
+     * Lines ids. Required to plot appropriate amount of lines.
+     * Notice that pointArrayMap should have more elements than
+     * linesApiNames, because it contains main line and additional lines ids.
+     * Also it should be consistent with amount of lines calculated in
+     * getValues method from your implementation.
+     *
+     * @private
+     * @name multipleLinesMixin.pointArrayMap
+     * @type {Array<string>}
+     */
+    var pointArrayMap = ['top', 'bottom'];
+    /**
+     * Names of the lines, bewteen which the area should be plotted.
+     * If the drawing of the area should
+     * be disabled for some indicators, leave this option as an empty array.
+     * Names should be the same as the names in the pointArrayMap.
+     * @private
+     * @name multipleLinesMixin.areaLinesNames
+     * @type {Array<string>}
+     */
+    var areaLinesNames = ['top'];
+    /**
+     * Main line id.
+     *
+     * @private
+     * @name multipleLinesMixin.pointValKey
+     * @type {string}
+     */
+    var pointValKey = 'top';
+    /* *
+     *
+     *  Functions
+     *
+     * */
+    /* eslint-disable valid-jsdoc */
+    /**
+     * @private
+     */
+    function compose(IndicatorClass) {
+        if (composedClasses.indexOf(IndicatorClass) === -1) {
+            composedClasses.push(IndicatorClass);
+            var proto = IndicatorClass.prototype;
+            proto.linesApiNames = (proto.linesApiNames ||
+                linesApiNames.slice());
+            proto.pointArrayMap = (proto.pointArrayMap ||
+                pointArrayMap.slice());
+            proto.pointValKey = (proto.pointValKey ||
+                pointValKey);
+            proto.areaLinesNames = (proto.areaLinesNames ||
+                areaLinesNames.slice());
+            proto.drawGraph = drawGraph;
+            proto.getGraphPath = getGraphPath;
+            proto.toYData = toYData;
+            proto.translate = translate;
+            proto.getTranslatedLinesNames = getTranslatedLinesNames;
+        }
+        return IndicatorClass;
+    }
+    MultipleLinesComposition.compose = compose;
+    /**
+     * Create the path based on points provided as argument.
+     * If indicator.nextPoints option is defined, create the areaFill.
+     *
+     * @param points Points on which the path should be created
+     */
+    function getGraphPath(points) {
+        var indicator = this;
+        var areaPath, path = [], higherAreaPath = [];
+        points = points || this.points;
+        // Render Span
+        if (indicator.fillGraph && indicator.nextPoints) {
+            areaPath = SMAIndicator.prototype.getGraphPath.call(indicator, indicator.nextPoints);
+            if (areaPath && areaPath.length) {
+                areaPath[0][0] = 'L';
+                path = SMAIndicator.prototype.getGraphPath.call(indicator, points);
+                higherAreaPath = areaPath.slice(0, path.length);
+                // Reverse points, so that the areaFill will start from the end:
+                for (var i = higherAreaPath.length - 1; i >= 0; i--) {
+                    path.push(higherAreaPath[i]);
+                }
+            }
+        }
+        else {
+            path = SMAIndicator.prototype.getGraphPath.apply(indicator, arguments);
+        }
+        return path;
+    }
+    /**
+     * Draw main and additional lines.
+     *
+     * @private
+     * @function multipleLinesMixin.drawGraph
+     */
+    function drawGraph() {
+        var indicator = this, pointValKey = indicator.pointValKey, linesApiNames = indicator.linesApiNames, areaLinesNames = indicator.areaLinesNames, mainLinePoints = indicator.points, mainLineOptions = indicator.options, mainLinePath = indicator.graph, gappedExtend = {
+            options: {
+                gapSize: mainLineOptions.gapSize
+            }
+        }, 
+        // additional lines point place holders:
+        secondaryLines = [], secondaryLinesNames = indicator.getTranslatedLinesNames(pointValKey);
+        var pointsLength = mainLinePoints.length, point;
+        // Generate points for additional lines:
+        secondaryLinesNames.forEach(function (plotLine, index) {
+            // create additional lines point place holders
+            secondaryLines[index] = [];
+            while (pointsLength--) {
+                point = mainLinePoints[pointsLength];
+                secondaryLines[index].push({
+                    x: point.x,
+                    plotX: point.plotX,
+                    plotY: point[plotLine],
+                    isNull: !defined(point[plotLine])
+                });
+            }
+            pointsLength = mainLinePoints.length;
+        });
+        // Modify options and generate area fill:
+        if (this.userOptions.fillColor && areaLinesNames.length) {
+            var index = secondaryLinesNames.indexOf(getLineName(areaLinesNames[0])), secondLinePoints = secondaryLines[index], firstLinePoints = areaLinesNames.length === 1 ?
+                mainLinePoints :
+                secondaryLines[secondaryLinesNames.indexOf(getLineName(areaLinesNames[1]))], originalColor = indicator.color;
+            indicator.points = firstLinePoints;
+            indicator.nextPoints = secondLinePoints;
+            indicator.color = this.userOptions.fillColor;
+            indicator.options = merge(mainLinePoints, gappedExtend);
+            indicator.graph = indicator.area;
+            indicator.fillGraph = true;
+            SeriesRegistry.seriesTypes.sma.prototype.drawGraph.call(indicator);
+            indicator.area = indicator.graph;
+            // Clean temporary properties:
+            delete indicator.nextPoints;
+            delete indicator.fillGraph;
+            indicator.color = originalColor;
+        }
+        // Modify options and generate additional lines:
+        linesApiNames.forEach(function (lineName, i) {
+            if (secondaryLines[i]) {
+                indicator.points = secondaryLines[i];
+                if (mainLineOptions[lineName]) {
+                    indicator.options = merge(mainLineOptions[lineName].styles, gappedExtend);
+                }
+                else {
+                    error('Error: "There is no ' + lineName +
+                        ' in DOCS options declared. Check if linesApiNames' +
+                        ' are consistent with your DOCS line names."' +
+                        ' at mixin/multiple-line.js:34');
+                }
+                indicator.graph = indicator['graph' + lineName];
+                SMAIndicator.prototype.drawGraph.call(indicator);
+                // Now save lines:
+                indicator['graph' + lineName] = indicator.graph;
+            }
+            else {
+                error('Error: "' + lineName + ' doesn\'t have equivalent ' +
+                    'in pointArrayMap. To many elements in linesApiNames ' +
+                    'relative to pointArrayMap."');
+            }
+        });
+        // Restore options and draw a main line:
+        indicator.points = mainLinePoints;
+        indicator.options = mainLineOptions;
+        indicator.graph = mainLinePath;
+        SMAIndicator.prototype.drawGraph.call(indicator);
+    }
+    /**
+     * Create translatedLines Collection based on pointArrayMap.
+     *
+     * @private
+     * @function multipleLinesMixin.getTranslatedLinesNames
+     * @param {string} [excludedValue]
+     *        Main line id
+     * @return {Array<string>}
+     *         Returns translated lines names without excluded value.
+     */
+    function getTranslatedLinesNames(excludedValue) {
+        var translatedLines = [];
+        (this.pointArrayMap || []).forEach(function (propertyName) {
+            if (propertyName !== excludedValue) {
+                translatedLines.push(getLineName(propertyName));
+            }
+        });
+        return translatedLines;
+    }
+    /**
+     * Generate the API name of the line
+     * @param propertyName name of the line
+     */
+    function getLineName(propertyName) {
+        return ('plot' +
+            propertyName.charAt(0).toUpperCase() +
+            propertyName.slice(1));
+    }
+    /**
+     * @private
+     * @function multipleLinesMixin.toYData
+     * @param {Highcharts.Point} point
+     *        Indicator point
+     * @return {Array<number>}
+     *         Returns point Y value for all lines
+     */
+    function toYData(point) {
+        var pointColl = [];
+        (this.pointArrayMap || []).forEach(function (propertyName) {
+            pointColl.push(point[propertyName]);
+        });
+        return pointColl;
+    }
+    /**
+     * Add lines plot pixel values.
+     *
+     * @private
+     * @function multipleLinesMixin.translate
+     */
+    function translate() {
+        var indicator = this, pointArrayMap = indicator.pointArrayMap;
+        var LinesNames = [], value;
+        LinesNames = indicator.getTranslatedLinesNames();
+        SMAIndicator.prototype.translate.apply(indicator, arguments);
+        indicator.points.forEach(function (point) {
+            pointArrayMap.forEach(function (propertyName, i) {
+                value = point[propertyName];
+                // If the modifier, like for example compare exists,
+                // modified the original value by that method, #15867.
+                if (indicator.dataModify) {
+                    value = indicator.dataModify.modifyValue(value);
+                }
+                if (value !== null) {
+                    point[LinesNames[i]] = indicator.yAxis.toPixels(value, true);
+                }
+            });
+        });
+    }
+})(MultipleLinesComposition || (MultipleLinesComposition = {}));
+/* *
+ *
+ *  Default Export
+ *
+ * */
+export default MultipleLinesComposition;

package/es-modules/Stock/Indicators/NATR/NATRIndicator.js

@@ -88,9 +88,6 @@ var NATRIndicator = /** @class */ (function (_super) {
     });
     return NATRIndicator;
 }(ATRIndicator));
-extend(NATRIndicator.prototype, {
-    requiredIndicators: ['atr']
-});
 SeriesRegistry.registerSeriesType('natr', NATRIndicator);
 /* *
  *
@@ -107,6 +104,7 @@ export default NATRIndicator;
  * @product   highstock
  * @excluding dataParser, dataURL
  * @requires  stock/indicators/indicators
+ * @requires  stock/indicators/atr
  * @requires  stock/indicators/natr
  * @apioption series.natr
  */

package/es-modules/Stock/Indicators/PC/PCIndicator.js

@@ -19,14 +19,13 @@ var __extends = (this && this.__extends) || (function () {
         d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
     };
 })();
-import palette from '../../../Core/Color/Palette.js';
-import MultipleLinesMixin from '../../../Mixins/MultipleLines.js';
-import ReduceArrayMixin from '../../../Mixins/ReduceArray.js';
+import AU from '../ArrayUtilities.js';
+import MultipleLinesComposition from '../MultipleLinesComposition.js';
+import Palettes from '../../../Core/Color/Palettes.js';
 import SeriesRegistry from '../../../Core/Series/SeriesRegistry.js';
 var SMAIndicator = SeriesRegistry.seriesTypes.sma;
 import U from '../../../Core/Utilities.js';
 var merge = U.merge, extend = U.extend;
-var getArrayExtremes = ReduceArrayMixin.getArrayExtremes;
 /* *
  *
  *  Class
@@ -44,6 +43,11 @@ var getArrayExtremes = ReduceArrayMixin.getArrayExtremes;
 var PCIndicator = /** @class */ (function (_super) {
     __extends(PCIndicator, _super);
     function PCIndicator() {
+        /* *
+         *
+         *  Static Properties
+         *
+         * */
         var _this = _super !== null && _super.apply(this, arguments) || this;
         /* *
         *
@@ -72,7 +76,7 @@ var PCIndicator = /** @class */ (function (_super) {
         for (i = period; i <= yValLen; i++) {
             date = xVal[i - 1];
             slicedY = yVal.slice(i - period, i);
-            extremes = getArrayExtremes(slicedY, low, high);
+            extremes = AU.getArrayExtremes(slicedY, low, high);
             TL = extremes[1];
             BL = extremes[0];
             ML = (TL + BL) / 2;
@@ -105,6 +109,16 @@ var PCIndicator = /** @class */ (function (_super) {
      * @optionparent plotOptions.pc
      */
     PCIndicator.defaultOptions = merge(SMAIndicator.defaultOptions, {
+        /**
+         * Option for fill color between lines in Price channel Indicator.
+         *
+         * @sample {highstock} stock/indicators/indicator-area-fill
+         *      background fill between lines
+         *
+         * @type {Highcharts.Color}
+         * @apioption plotOptions.pc.fillColor
+         *
+         */
         /**
          * @excluding index
          */
@@ -121,7 +135,7 @@ var PCIndicator = /** @class */ (function (_super) {
                  *
                  * @type {Highcharts.ColorString}
                  */
-                lineColor: palette.colors[2],
+                lineColor: Palettes.colors[2],
                 /**
                  * Pixel width of the line.
                  */
@@ -136,7 +150,7 @@ var PCIndicator = /** @class */ (function (_super) {
                  *
                  * @type {Highcharts.ColorString}
                  */
-                lineColor: palette.colors[8],
+                lineColor: Palettes.colors[8],
                 /**
                  * Pixel width of the line.
                  */
@@ -150,16 +164,14 @@ var PCIndicator = /** @class */ (function (_super) {
     return PCIndicator;
 }(SMAIndicator));
 extend(PCIndicator.prototype, {
-    getTranslatedLinesNames: MultipleLinesMixin.getTranslatedLinesNames,
-    drawGraph: MultipleLinesMixin.drawGraph,
-    toYData: MultipleLinesMixin.toYData,
-    pointArrayMap: ['top', 'middle', 'bottom'],
-    pointValKey: 'middle',
+    areaLinesNames: ['top', 'bottom'],
     nameBase: 'Price Channel',
     nameComponents: ['period'],
     linesApiNames: ['topLine', 'bottomLine'],
-    translate: MultipleLinesMixin.translate
+    pointArrayMap: ['top', 'middle', 'bottom'],
+    pointValKey: 'middle'
 });
+MultipleLinesComposition.compose(PCIndicator);
 SeriesRegistry.registerSeriesType('pc', PCIndicator);
 /* *
  *

package/es-modules/Stock/Indicators/PPO/PPOIndicator.js

@@ -19,7 +19,6 @@ var __extends = (this && this.__extends) || (function () {
         d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
     };
 })();
-import RequiredIndicatorMixin from '../../../Mixins/IndicatorRequired.js';
 import SeriesRegistry from '../../../Core/Series/SeriesRegistry.js';
 var EMAIndicator = SeriesRegistry.seriesTypes.ema;
 import U from '../../../Core/Utilities.js';
@@ -57,13 +56,6 @@ var PPOIndicator = /** @class */ (function (_super) {
      *  Functions
      *
      * */
-    PPOIndicator.prototype.init = function () {
-        var args = arguments, ctx = this;
-        RequiredIndicatorMixin.isParentLoaded(EMAIndicator, 'ema', ctx.type, function (indicator) {
-            indicator.prototype.init.apply(ctx, args);
-            return;
-        });
-    };
     PPOIndicator.prototype.getValues = function (series, params) {
         var periods = params.periods, index = params.index, 
         // 0- date, 1- Percentage Price Oscillator
@@ -109,7 +101,7 @@ var PPOIndicator = /** @class */ (function (_super) {
     /**
      * Percentage Price Oscillator. This series requires the
      * `linkedTo` option to be set and should be loaded after the
-     * `stock/indicators/indicators.js` and `stock/indicators/ema.js`.
+     * `stock/indicators/indicators.js`.
      *
      * @sample {highstock} stock/indicators/ppo
      *         Percentage Price Oscillator
@@ -121,7 +113,6 @@ var PPOIndicator = /** @class */ (function (_super) {
      *               pointInterval, pointIntervalUnit, pointPlacement,
      *               pointRange, pointStart, showInNavigator, stacking
      * @requires     stock/indicators/indicators
-     * @requires     stock/indicators/ema
      * @requires     stock/indicators/ppo
      * @optionparent plotOptions.ppo
      */
@@ -167,7 +158,6 @@ export default PPOIndicator;
  *            navigatorOptions, pointInterval, pointIntervalUnit,
  *            pointPlacement, pointRange, pointStart, showInNavigator, stacking
  * @requires  stock/indicators/indicators
- * @requires  stock/indicators/ema
  * @requires  stock/indicators/ppo
  * @apioption series.ppo
  */

package/es-modules/Stock/Indicators/PivotPoints/PivotPointsIndicator.js

@@ -145,7 +145,8 @@ var PivotPointsIndicator = /** @class */ (function (_super) {
                                     null;
                     }
                 }
-                SeriesRegistry.seriesTypes.sma.prototype.drawDataLabels.apply(indicator, arguments);
+                SeriesRegistry.seriesTypes.sma.prototype.drawDataLabels
+                    .apply(indicator, arguments);
             });
         }
     };

package/es-modules/Stock/Indicators/RSI/RSIIndicator.js

@@ -73,7 +73,8 @@ var RSIIndicator = /** @class */ (function (_super) {
             // longer then 4 (HLC, range), this ensures that we are not trying
             // to reach the index out of bounds
             index = Math.min(index, yVal[0].length - 1);
-            values = yVal.map(function (value) { return value[index]; });
+            values = yVal
+                .map(function (value) { return value[index]; });
         }
         // Calculate changes for first N points
         while (range < period) {

package/es-modules/Stock/Indicators/SMA/SMAComposition.js

@@ -10,29 +10,3 @@ import SeriesRegistry from '../../../Core/Series/SeriesRegistry.js';
 var Series = SeriesRegistry.series, ohlcProto = SeriesRegistry.seriesTypes.ohlc.prototype;
 import U from '../../../Core/Utilities.js';
 var addEvent = U.addEvent, extend = U.extend;
-/* *
- *
- *  Composition
- *
- * */
-addEvent(Series, 'init', function (eventOptions) {
-    // eslint-disable-next-line no-invalid-this
-    var series = this, options = eventOptions.options;
-    if (options.useOhlcData &&
-        options.id !== 'highcharts-navigator-series') {
-        extend(series, {
-            pointValKey: ohlcProto.pointValKey,
-            // keys: ohlcProto.keys, // @todo potentially nonsense
-            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';
-    }
-});

package/es-modules/Stock/Indicators/SMA/SMAIndicator.js

@@ -20,13 +20,11 @@ var __extends = (this && this.__extends) || (function () {
     };
 })();
 import Chart from '../../../Core/Chart/Chart.js';
-import RequiredIndicatorMixin from '../../../Mixins/IndicatorRequired.js';
 import SeriesRegistry from '../../../Core/Series/SeriesRegistry.js';
 var LineSeries = SeriesRegistry.seriesTypes.line;
 import U from '../../../Core/Utilities.js';
 var addEvent = U.addEvent, error = U.error, extend = U.extend, isArray = U.isArray, merge = U.merge, pick = U.pick, splat = U.splat;
 import './SMAComposition.js';
-var generateMessage = RequiredIndicatorMixin.generateMessage;
 /* *
  *
  *  Class
@@ -127,36 +125,40 @@ var SMAIndicator = /** @class */ (function (_super) {
      * @private
      */
     SMAIndicator.prototype.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));
-        }
+        var indicator = this;
         _super.prototype.init.call(indicator, chart, options);
         // Only after series are linked indicator can be processed.
         var linkedSeriesUnbiner = addEvent(Chart, 'afterLinkSeries', function () {
             var hasEvents = !!indicator.dataEventsToUnbind.length;
             if (indicator.linkedParent) {
                 if (!hasEvents) {
-                    indicator.dataEventsToUnbind.push(addEvent(indicator.bindTo.series ?
-                        indicator.linkedParent :
-                        indicator.linkedParent.xAxis, indicator.bindTo.eventName, function () {
+                    // No matter which indicator, always recalculate after
+                    // updating the data.
+                    indicator.dataEventsToUnbind.push(addEvent(indicator.linkedParent, 'updatedData', function () {
                         indicator.recalculateValues();
                     }));
+                    // Some indicators (like VBP) requires an additional
+                    // event (afterSetExtremes) to properly show the data.
+                    if (indicator.calculateOn.xAxis) {
+                        indicator.dataEventsToUnbind.push(addEvent(indicator.linkedParent.xAxis, indicator.calculateOn.xAxis, function () {
+                            indicator.recalculateValues();
+                        }));
+                    }
                 }
-                if (indicator.calculateOn === 'init') {
+                // Most indicators are being calculated on chart's init.
+                if (indicator.calculateOn.chart === 'init') {
                     if (!indicator.processedYData) {
                         indicator.recalculateValues();
                     }
                 }
-                else {
-                    if (!hasEvents) {
-                        var unbinder_1 = addEvent(indicator.chart, indicator.calculateOn, function () {
-                            indicator.recalculateValues();
-                            // Call this just once, on init
-                            unbinder_1();
-                        });
-                    }
+                else if (!hasEvents) {
+                    // Some indicators (like VBP) has to recalculate their
+                    // values after other chart's events (render).
+                    var unbinder_1 = addEvent(indicator.chart, indicator.calculateOn.chart, function () {
+                        indicator.recalculateValues();
+                        // Call this just once.
+                        unbinder_1();
+                    });
                 }
             }
             else {
@@ -174,7 +176,6 @@ var SMAIndicator = /** @class */ (function (_super) {
     };
     /**
      * @private
-     * @return {void}
      */
     SMAIndicator.prototype.recalculateValues = function () {
         var indicator = this, oldData = indicator.points || [], oldDataLength = (indicator.xData || []).length, processedData = (indicator.getValues(indicator.linkedParent, indicator.options.params) || {
@@ -227,7 +228,7 @@ var SMAIndicator = /** @class */ (function (_super) {
         }
         // Removal of processedXData property is required because on
         // first translate processedXData array is empty
-        if (indicator.bindTo.series === false) {
+        if (indicator.calculateOn.xAxis && indicator.processedXData) {
             delete indicator.processedXData;
             indicator.isDirty = true;
             indicator.redraw();
@@ -240,31 +241,16 @@ var SMAIndicator = /** @class */ (function (_super) {
     SMAIndicator.prototype.processData = function () {
         var series = this, compareToMain = series.options.compareToMain, linkedParent = series.linkedParent;
         _super.prototype.processData.apply(series, arguments);
-        if (linkedParent && linkedParent.compareValue && compareToMain) {
-            series.compareValue = linkedParent.compareValue;
+        if (series.dataModify &&
+            linkedParent &&
+            linkedParent.dataModify &&
+            linkedParent.dataModify.compareValue &&
+            compareToMain) {
+            series.dataModify.compareValue =
+                linkedParent.dataModify.compareValue;
         }
         return;
     };
-    /**
-     * @private
-     */
-    SMAIndicator.prototype.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 (SeriesRegistry.seriesTypes[indicator]) {
-                SeriesRegistry.seriesTypes[indicator].prototype.requireIndicators();
-            }
-            else {
-                obj.allLoaded = false;
-                obj.needed = indicator;
-            }
-        });
-        return obj;
-    };
     /**
      * The parameter allows setting line series type and use OHLC indicators.
      * Data in OHLC format is required.
@@ -335,7 +321,7 @@ var SMAIndicator = /** @class */ (function (_super) {
              * example using OHLC data, index=2 means the indicator will be
              * calculated using Low values.
              */
-            index: 0,
+            index: 3,
             /**
              * The base period for indicator calculations. This is the number of
              * data points which are taken into account for the indicator
@@ -347,16 +333,12 @@ var SMAIndicator = /** @class */ (function (_super) {
     return SMAIndicator;
 }(LineSeries));
 extend(SMAIndicator.prototype, {
-    bindTo: {
-        series: true,
-        eventName: 'updatedData'
+    calculateOn: {
+        chart: 'init'
     },
-    calculateOn: 'init',
     hasDerivedData: true,
     nameComponents: ['period'],
     nameSuffixes: [],
-    // Defines on which other indicators is this indicator based on.
-    requiredIndicators: [],
     useCommonDataGrouping: true
 });
 SeriesRegistry.registerSeriesType('sma', SMAIndicator);

package/es-modules/Stock/Indicators/SlowStochastic/SlowStochasticIndicator.js

@@ -19,7 +19,6 @@ var __extends = (this && this.__extends) || (function () {
         d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
     };
 })();
-import RequiredIndicatorMixin from '../../../Mixins/IndicatorRequired.js';
 import SeriesRegistry from '../../../Core/Series/SeriesRegistry.js';
 var StochasticIndicator = SeriesRegistry.seriesTypes.stochastic;
 var seriesTypes = SeriesRegistry.seriesTypes;
@@ -43,13 +42,6 @@ var SlowStochasticIndicator = /** @class */ (function (_super) {
         _this.points = void 0;
         return _this;
     }
-    SlowStochasticIndicator.prototype.init = function () {
-        var args = arguments, ctx = this;
-        RequiredIndicatorMixin.isParentLoaded(seriesTypes.stochastic, 'stochastic', ctx.type, function (indicator) {
-            indicator.prototype.init.apply(ctx, args);
-            return;
-        });
-    };
     SlowStochasticIndicator.prototype.getValues = function (series, params) {
         var periods = params.periods, fastValues = seriesTypes.stochastic.prototype.getValues.call(this, series, params), slowValues = {
             values: [],