@amcharts/amcharts5 5.1.14 → 5.2.2

package/.internal/charts/stock/StockChart.js

@@ -0,0 +1,700 @@
+import { __extends } from "tslib";
+import { PanelControls } from "./PanelControls";
+import { StockChartDefaultTheme } from "./StockChartDefaultTheme";
+import { XYChartDefaultTheme } from "../xy/XYChartDefaultTheme";
+import { Container } from "../../core/render/Container";
+import { ListAutoDispose } from "../../core/util/List";
+import { Rectangle } from "../../core/render/Rectangle";
+import { p100, percent } from "../../core/util/Percent";
+import { SettingsModal } from "./SettingsModal";
+import { Color } from "../../core/util/Color";
+import { registry } from "../../core/Registry";
+import * as $array from "../../core/util/Array";
+import * as $utils from "../../core/util/Utils";
+import * as $object from "../../core/util/Object";
+/**
+ * A main class for the Stock Chart.
+ *
+ * @see {@link https://www.amcharts.com/docs/v5/charts/stock/} for more info
+ * @important
+ */
+var StockChart = /** @class */ (function (_super) {
+    __extends(StockChart, _super);
+    function StockChart() {
+        var _this = _super !== null && _super.apply(this, arguments) || this;
+        Object.defineProperty(_this, "_xAxes", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(_this, "_downY", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(_this, "_upperPanel", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(_this, "_dhp", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(_this, "_uhp", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(_this, "_downResizer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        /**
+         * A list of stock panels.
+         *
+         * @see {@link https://www.amcharts.com/docs/v5/charts/stock/#Panels} for more info
+         */
+        Object.defineProperty(_this, "panels", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new ListAutoDispose()
+        });
+        /**
+         * A list of indicators on chart.
+         *
+         * @see {@link https://www.amcharts.com/docs/v5/charts/stock/indicators/} for more info
+         */
+        Object.defineProperty(_this, "indicators", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new ListAutoDispose()
+        });
+        /**
+         * A [[Container]], resiting on top of the charts, suitable for additional
+         * tools, like [[Scrollbar]].
+         *
+         * @default Container.new()
+         */
+        Object.defineProperty(_this, "toolsContainer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: _this.children.push(Container.new(_this._root, { width: p100, themeTags: [] }))
+        });
+        /**
+         * A [[Container]] where all the stock panels are placed into.
+         *
+         * @default Container.new()
+         */
+        Object.defineProperty(_this, "panelsContainer", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: _this.children.push(Container.new(_this._root, { width: p100, height: p100, layout: _this._root.verticalLayout, themeTags: ["chartscontainer"] }))
+        });
+        return _this;
+    }
+    Object.defineProperty(StockChart.prototype, "_afterNew", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function () {
+            var _this = this;
+            this._settings.themeTags = $utils.mergeTags(this._settings.themeTags, ["stock"]);
+            this._defaultThemes.push(StockChartDefaultTheme.new(this._root));
+            this._defaultThemes.push(XYChartDefaultTheme.new(this._root));
+            var tooltipContainer = this._root.tooltipContainer;
+            tooltipContainer.set("themeTags", $utils.mergeTags(tooltipContainer.get("themeTags", []), ["stock"]));
+            _super.prototype._afterNew.call(this);
+            var children = this.panelsContainer.children;
+            this._disposers.push(this.panels.events.onAll(function (change) {
+                if (change.type === "clear") {
+                    $array.each(change.oldValues, function (chart) {
+                        _this._removePanel(chart);
+                    });
+                }
+                else if (change.type === "push") {
+                    children.moveValue(change.newValue);
+                    _this._processPanel(change.newValue);
+                }
+                else if (change.type === "setIndex") {
+                    children.setIndex(change.index, change.newValue);
+                    _this._processPanel(change.newValue);
+                }
+                else if (change.type === "insertIndex") {
+                    children.insertIndex(change.index, change.newValue);
+                    _this._processPanel(change.newValue);
+                }
+                else if (change.type === "removeIndex") {
+                    _this._removePanel(change.oldValue);
+                }
+                else {
+                    throw new Error("Unknown IListEvent type");
+                }
+            }));
+            this._disposers.push(this.indicators.events.onAll(function (change) {
+                if (change.type === "clear") {
+                    $array.each(change.oldValues, function (indicator) {
+                        _this._removeIndicator(indicator);
+                    });
+                }
+                else if (change.type === "push") {
+                    _this._processIndicator(change.newValue);
+                }
+                else if (change.type === "setIndex") {
+                    _this._processIndicator(change.newValue);
+                }
+                else if (change.type === "insertIndex") {
+                    _this._processIndicator(change.newValue);
+                }
+                else if (change.type === "removeIndex") {
+                    _this._removeIndicator(change.oldValue);
+                }
+                else {
+                    throw new Error("Unknown IListEvent type");
+                }
+            }));
+            this.setPrivateRaw("settingsModal", SettingsModal.new(this.root, {
+                stockChart: this
+            }));
+            var license = false;
+            for (var i = 0; i < registry.licenses.length; i++) {
+                if (registry.licenses[i].match(/^AM5S.{5,}/i)) {
+                    license = true;
+                }
+            }
+            if (!license) {
+                this._root._showBranding();
+            }
+            else {
+                this._root._licenseApplied();
+            }
+        }
+    });
+    Object.defineProperty(StockChart.prototype, "_prepareChildren", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function () {
+            if (this.isDirty("volumeNegativeColor") || this.isDirty("volumePositiveColor")) {
+                var volumeSeries = this.get("volumeSeries");
+                if (volumeSeries && volumeSeries.isType("BaseColumnSeries")) {
+                    volumeSeries.columns.each(function (column) {
+                        column._markDirtyKey("fill");
+                    });
+                }
+            }
+            var stockSeries = this.get("stockSeries");
+            if (this.isDirty("stockNegativeColor") || this.isDirty("stockPositiveColor")) {
+                if (stockSeries && stockSeries.isType("BaseColumnSeries")) {
+                    var stockNegativeColor_1 = this.get("stockNegativeColor", this._root.interfaceColors.get("negative"));
+                    var stockPositiveColor_1 = this.get("stockPositiveColor", this._root.interfaceColors.get("positive"));
+                    var previous_1 = stockSeries.dataItems[0];
+                    $array.each(stockSeries.dataItems, function (dataItem) {
+                        var column = dataItem.get("graphics");
+                        if (column) {
+                            var dropFromOpen = column.states.lookup("dropFromOpen");
+                            if (dropFromOpen) {
+                                dropFromOpen.setAll({ fill: stockNegativeColor_1, stroke: stockNegativeColor_1 });
+                            }
+                            var riseFromOpen = column.states.lookup("riseFromOpen");
+                            if (riseFromOpen) {
+                                riseFromOpen.setAll({ fill: stockPositiveColor_1, stroke: stockPositiveColor_1 });
+                            }
+                            stockSeries._applyGraphicsStates(dataItem, previous_1);
+                            previous_1 = dataItem;
+                        }
+                    });
+                    stockSeries.markDirtyValues();
+                }
+            }
+            if (this.isDirty("stockSeries")) {
+                if (stockSeries) {
+                    this.indicators.each(function (indicator) {
+                        indicator.set("stockSeries", stockSeries);
+                    });
+                    var mainChart = stockSeries.chart;
+                    if (mainChart) {
+                        var previous_2 = this._prevSettings.stockSeries;
+                        mainChart.series.each(function (series) {
+                            if (series.isType("DrawingSeries")) {
+                                var s = series.get("series");
+                                if (s == previous_2) {
+                                    series.set("series", stockSeries);
+                                }
+                            }
+                        });
+                    }
+                    if (this.getPrivate("comparing")) {
+                        this.setPercentScale(true);
+                    }
+                }
+            }
+            _super.prototype._prepareChildren.call(this);
+        }
+    });
+    /**
+     * Enables or disables percent scale mode.
+     *
+     * If `percentScale` is not set, it will try to determine the status on its own.
+     *
+     * In percent scale mode `percentScaleSeriesSettings` and `percentScaleValueAxisSettings` will
+     * be applied to the regular series on the main panel and its Y axis.
+     *
+     * @param  percentScale  Comparison mode active
+     */
+    Object.defineProperty(StockChart.prototype, "setPercentScale", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (percentScale) {
+            var _this = this;
+            var stockSeries = this.get("stockSeries");
+            var seriesSettings = this.get("percentScaleSeriesSettings");
+            var axisSettings = this.get("percentScaleValueAxisSettings");
+            if (stockSeries) {
+                var mainChart = stockSeries.chart;
+                var yAxis_1 = stockSeries.get("yAxis");
+                this._maybePrepAxisDefaults();
+                if (mainChart) {
+                    var seriesList_1 = [];
+                    mainChart.series.each(function (series) {
+                        if (series.get("yAxis") == yAxis_1) {
+                            seriesList_1.push(series);
+                            _this._maybePrepSeriesDefaults(series);
+                        }
+                    });
+                    if (percentScale == undefined) {
+                        percentScale = this.getPrivate("comparedSeries", []).length > 0;
+                    }
+                    this.setPrivate("comparing", percentScale);
+                    if (seriesSettings) {
+                        $array.each(seriesList_1, function (series) {
+                            if (percentScale) {
+                                series.setAll(seriesSettings);
+                            }
+                            else {
+                                series.states.apply("comparingDefaults");
+                            }
+                        });
+                    }
+                    if (axisSettings) {
+                        if (percentScale) {
+                            yAxis_1.setAll(axisSettings);
+                        }
+                        else {
+                            yAxis_1.states.apply("comparingDefaults");
+                        }
+                    }
+                }
+            }
+        }
+    });
+    /**
+     * Adds a "compared" series to chart. Returns the same series.
+     *
+     * @param   series  Compared series
+     * @return          Compared series
+     */
+    Object.defineProperty(StockChart.prototype, "addComparingSeries", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (series) {
+            var _this = this;
+            var stockSeries = this.get("stockSeries");
+            if (stockSeries) {
+                var chart = stockSeries.chart;
+                if (chart) {
+                    chart.series.push(series);
+                }
+                // Apply comparingSeriesSettings
+                var comparingSeriesSettings = this.get("comparingSeriesSettings");
+                if (comparingSeriesSettings) {
+                    series.setAll(comparingSeriesSettings);
+                }
+                var comparedSeries = this.getPrivate("comparedSeries");
+                if (comparedSeries) {
+                    comparedSeries.push(series);
+                }
+                else {
+                    this.setPrivate("comparedSeries", [series]);
+                }
+                var legendDataItem = stockSeries.get("legendDataItem");
+                if (legendDataItem) {
+                    var legend = legendDataItem.component;
+                    if (legend.isType("StockLegend")) {
+                        legend.data.push(series);
+                        var ldi = series.get("legendDataItem");
+                        if (ldi) {
+                            var closeButton = ldi.get("closeButton");
+                            closeButton.set("forceHidden", false);
+                            closeButton.events.on("click", function () {
+                                _this.removeComparingSeries(series);
+                            });
+                        }
+                    }
+                }
+                if (this.get("autoSetPercentScale")) {
+                    this.setPercentScale(true);
+                }
+            }
+            return series;
+        }
+    });
+    /**
+     * Removes compared series.
+     *
+     * @param  series  Compared series
+     */
+    Object.defineProperty(StockChart.prototype, "removeComparingSeries", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (series) {
+            var stockSeries = this.get("stockSeries");
+            if (stockSeries) {
+                var chart = stockSeries.chart;
+                if (chart) {
+                    chart.series.removeValue(series);
+                }
+                var comparedSeries = this.getPrivate("comparedSeries");
+                if (comparedSeries) {
+                    $array.remove(comparedSeries, series);
+                    if (comparedSeries.length == 0 && this.get("autoSetPercentScale")) {
+                        this.setPercentScale(true);
+                    }
+                }
+            }
+            var ldi = series.get("legendDataItem");
+            if (ldi) {
+                var legend = ldi.component;
+                legend.data.removeValue(series);
+            }
+        }
+    });
+    Object.defineProperty(StockChart.prototype, "_maybePrepSeriesDefaults", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (series) {
+            if (!series.states.lookup("comparingDefaults")) {
+                var seriesSettings = this.get("percentScaleSeriesSettings");
+                var defaults_1 = {};
+                $object.each(seriesSettings, function (key, _val) {
+                    defaults_1[key] = series.get(key);
+                });
+                series.states.create("comparingDefaults", defaults_1);
+            }
+        }
+    });
+    Object.defineProperty(StockChart.prototype, "_maybePrepAxisDefaults", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function () {
+            var stockSeries = this.get("stockSeries");
+            var axis = stockSeries.get("yAxis");
+            if (!axis.states.lookup("comparingDefaults")) {
+                var axisSettings = this.get("percentScaleValueAxisSettings");
+                var defaults_2 = {};
+                $object.each(axisSettings, function (key, _val) {
+                    defaults_2[key] = axis.get(key);
+                });
+                axis.states.create("comparingDefaults", defaults_2);
+            }
+        }
+    });
+    Object.defineProperty(StockChart.prototype, "_processIndicator", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (indicator) {
+            this.children.push(indicator);
+            var stockSeries = this.get("stockSeries");
+            if (stockSeries) {
+                indicator.set("stockSeries", stockSeries);
+            }
+            var volumeSeries = this.get("volumeSeries");
+            if (volumeSeries) {
+                indicator.set("volumeSeries", volumeSeries);
+            }
+            if (this.getPrivate("comparing")) {
+                this.setPercentScale(true);
+            }
+            indicator.prepareData();
+        }
+    });
+    Object.defineProperty(StockChart.prototype, "_removeIndicator", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (indicator) {
+            this.children.removeValue(indicator);
+        }
+    });
+    Object.defineProperty(StockChart.prototype, "_removePanel", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (chart) {
+            this.panelsContainer.children.removeValue(chart);
+        }
+    });
+    Object.defineProperty(StockChart.prototype, "_updateControls", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function () {
+            var _this = this;
+            var stockSeries = this.get("stockSeries");
+            this.panels.each(function (panel) {
+                var panelControls = panel.panelControls;
+                var index = _this.panelsContainer.children.indexOf(panel);
+                var len = _this.panels.length;
+                panelControls.upButton.setPrivate("visible", false);
+                panelControls.downButton.setPrivate("visible", false);
+                panelControls.expandButton.setPrivate("visible", false);
+                panelControls.closeButton.setPrivate("visible", false);
+                if (len > 1) {
+                    panelControls.expandButton.setPrivate("visible", true);
+                    if (index != 0) {
+                        panelControls.upButton.setPrivate("visible", true);
+                    }
+                    if (index != len - 1) {
+                        panelControls.downButton.setPrivate("visible", true);
+                    }
+                    if (!stockSeries || stockSeries.chart != panel) {
+                        panelControls.closeButton.setPrivate("visible", true);
+                    }
+                }
+                if (stockSeries) {
+                    _this.indicators.each(function (indicator) {
+                        indicator.set("stockSeries", stockSeries);
+                    });
+                }
+            });
+        }
+    });
+    Object.defineProperty(StockChart.prototype, "_processPanel", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (panel) {
+            var _this = this;
+            panel.setPrivate("otherCharts", this.panels.values);
+            panel.setPrivate("stockChart", this);
+            panel.panelControls = panel.topPlotContainer.children.push(PanelControls.new(this._root, { stockPanel: panel, stockChart: this }));
+            this._updateControls();
+            if (this.panels.length > 1) {
+                var resizer = panel.children.push(Rectangle.new(this._root, { themeTags: ["panelresizer"] }));
+                resizer.events.on("pointerdown", function (e) {
+                    var chartsContainer = _this.panelsContainer;
+                    _this._downResizer = e.target;
+                    _this.panels.each(function (chart) {
+                        chart.set("height", percent(chart.height() / chartsContainer.height() * 100));
+                    });
+                    _this._downY = chartsContainer.toLocal(e.point).y;
+                    var upperChart = _this.panels.getIndex(_this.panels.indexOf(panel) - 1);
+                    _this._upperPanel = upperChart;
+                    if (upperChart) {
+                        _this._uhp = upperChart.get("height");
+                    }
+                    _this._dhp = panel.get("height");
+                });
+                resizer.events.on("pointerup", function () {
+                    _this._downResizer = undefined;
+                });
+                resizer.events.on("globalpointermove", function (e) {
+                    if (e.target == _this._downResizer) {
+                        var chartsContainer = _this.panelsContainer;
+                        var height = chartsContainer.height();
+                        var upperChart = _this._upperPanel;
+                        if (upperChart) {
+                            var index = _this.panels.indexOf(upperChart) + 2;
+                            var max = height - panel.get("minHeight", 0);
+                            var lowerChart = _this.panels.getIndex(index);
+                            if (lowerChart) {
+                                max = lowerChart.y() - panel.get("minHeight", 0);
+                            }
+                            console.log(upperChart.get("minHeight", 0));
+                            var y = Math.max(upperChart.y() + upperChart.get("minHeight", 0) + upperChart.get("paddingTop", 0), Math.min(chartsContainer.toLocal(e.point).y, max));
+                            var downY = _this._downY;
+                            var dhp = _this._dhp;
+                            var uhp = _this._uhp;
+                            if (downY != null && dhp != null && uhp != null) {
+                                var diff = (downY - y) / height;
+                                panel.set("height", percent((dhp.value + diff) * 100));
+                                upperChart.set("height", percent((uhp.value - diff) * 100));
+                            }
+                        }
+                    }
+                });
+            }
+            panel.xAxes.events.onAll(function (change) {
+                if (change.type === "clear") {
+                    $array.each(change.oldValues, function (axis) {
+                        _this._removeXAxis(axis);
+                    });
+                }
+                else if (change.type === "push") {
+                    _this._processXAxis(change.newValue);
+                }
+                else if (change.type === "setIndex") {
+                    _this._processXAxis(change.newValue);
+                }
+                else if (change.type === "insertIndex") {
+                    _this._processXAxis(change.newValue);
+                }
+                else if (change.type === "removeIndex") {
+                    _this._removeXAxis(change.oldValue);
+                }
+                else {
+                    throw new Error("Unknown IListEvent type");
+                }
+            });
+            panel.leftAxesContainer.events.on("boundschanged", function () {
+                _this._syncYAxesSize();
+            });
+            panel.rightAxesContainer.events.on("boundschanged", function () {
+                _this._syncYAxesSize();
+            });
+        }
+    });
+    Object.defineProperty(StockChart.prototype, "_syncYAxesSize", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function () {
+            var maxLeft = 0;
+            var maxRight = 0;
+            this.panels.each(function (chart) {
+                var lw = chart.leftAxesContainer.width();
+                var rw = chart.rightAxesContainer.width();
+                if (lw > maxLeft) {
+                    maxLeft = lw;
+                }
+                if (rw > maxRight) {
+                    maxRight = rw;
+                }
+            });
+            this.panels.each(function (chart) {
+                chart.leftAxesContainer.set("minWidth", maxLeft);
+                chart.rightAxesContainer.set("minWidth", maxRight);
+            });
+            this.toolsContainer.set("paddingRight", maxRight);
+            this.toolsContainer.set("paddingRight", maxRight);
+        }
+    });
+    Object.defineProperty(StockChart.prototype, "_removeXAxis", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (_axis) {
+        }
+    });
+    Object.defineProperty(StockChart.prototype, "_processXAxis", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (axis) {
+            var _this = this;
+            $array.move(this._xAxes, axis);
+            axis.on("start", function () {
+                if (axis._skipSync != true) {
+                    _this._syncXAxes(axis);
+                }
+            });
+            axis.on("end", function () {
+                if (axis._skipSync != true) {
+                    _this._syncXAxes(axis);
+                }
+            });
+        }
+    });
+    Object.defineProperty(StockChart.prototype, "_syncXAxes", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (axis) {
+            $array.each(this._xAxes, function (xAxis) {
+                if (xAxis != axis) {
+                    xAxis._skipSync = true;
+                    xAxis.set("start", axis.get("start"));
+                    xAxis.set("end", axis.get("end"));
+                    xAxis._skipSync = false;
+                }
+            });
+        }
+    });
+    /**
+     * @ignore
+     */
+    Object.defineProperty(StockChart.prototype, "getVolumeColor", {
+        enumerable: false,
+        configurable: true,
+        writable: true,
+        value: function (dataItem, negativeColor, positiveColor) {
+            if (dataItem) {
+                var stockSeries = this.get("stockSeries");
+                var volumeSeries = dataItem.component;
+                if (!negativeColor) {
+                    negativeColor = this.get("volumeNegativeColor", this.root.interfaceColors.get("negative", Color.fromHex(0xff0000)));
+                }
+                if (!positiveColor) {
+                    positiveColor = this.get("volumePositiveColor", this.root.interfaceColors.get("positive", Color.fromHex(0x00FF00)));
+                }
+                if (stockSeries && volumeSeries) {
+                    var index = volumeSeries.dataItems.indexOf(dataItem);
+                    if (index > 0) {
+                        var stockDataItem = stockSeries.dataItems[index];
+                        if (stockDataItem) {
+                            var close_1 = stockDataItem.get("valueY");
+                            if (close_1 != null) {
+                                for (var i = index - 1; i >= 0; i--) {
+                                    var di = stockSeries.dataItems[i];
+                                    var previousClose = di.get("valueY");
+                                    if (previousClose != null) {
+                                        if (close_1 < previousClose) {
+                                            return negativeColor;
+                                        }
+                                        else {
+                                            return positiveColor;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            return positiveColor;
+        }
+    });
+    Object.defineProperty(StockChart, "className", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: "StockChart"
+    });
+    Object.defineProperty(StockChart, "classNames", {
+        enumerable: true,
+        configurable: true,
+        writable: true,
+        value: Container.classNames.concat([StockChart.className])
+    });
+    return StockChart;
+}(Container));
+export { StockChart };
+//# sourceMappingURL=StockChart.js.map