@fintatech/fintachart 3.1.0

package/scripts/frameworks-modified/toastr.js

@@ -0,0 +1,414 @@
+'use strict';
+
+var FintaChart;
+(function (FintaChart) {
+    var External;
+    (function (External) {
+
+        (function (define) {
+            define(['jquery'], function ($) {
+                return (function () {
+                    var $container;
+                    var listener;
+                    var toastId = 0;
+                    var toastType = {
+                        error: 'error',
+                        info: 'info',
+                        success: 'success',
+                        warning: 'warning'
+                    };
+
+                    var toastr = {
+                        clear: clear,
+                        remove: remove,
+                        error: error,
+                        getContainer: getContainer,
+                        info: info,
+                        options: {},
+                        subscribe: subscribe,
+                        success: success,
+                        version: '2.1.1',
+                        warning: warning
+                    };
+
+                    var previousToast;
+
+                    return toastr;
+
+                    ////////////////
+
+                    function error(message, title, optionsOverride) {
+                        return notify({
+                            type: toastType.error,
+                            iconClass: getOptions().iconClasses.error,
+                            message: message,
+                            optionsOverride: optionsOverride,
+                            title: title
+                        });
+                    }
+
+                    function getContainer(options, create) {
+                        if (!options) { options = getOptions(); }
+                        $container = $('#' + options.containerId);
+                        if ($container.length) {
+                            return $container;
+                        }
+                        if (create) {
+                            $container = createContainer(options);
+                        }
+                        return $container;
+                    }
+
+                    function info(message, title, optionsOverride) {
+                        return notify({
+                            type: toastType.info,
+                            iconClass: getOptions().iconClasses.info,
+                            message: message,
+                            optionsOverride: optionsOverride,
+                            title: title
+                        });
+                    }
+
+                    function subscribe(callback) {
+                        listener = callback;
+                    }
+
+                    function success(message, title, optionsOverride) {
+                        return notify({
+                            type: toastType.success,
+                            iconClass: getOptions().iconClasses.success,
+                            message: message,
+                            optionsOverride: optionsOverride,
+                            title: title
+                        });
+                    }
+
+                    function warning(message, title, optionsOverride) {
+                        return notify({
+                            type: toastType.warning,
+                            iconClass: getOptions().iconClasses.warning,
+                            message: message,
+                            optionsOverride: optionsOverride,
+                            title: title
+                        });
+                    }
+
+                    function clear($toastElement, clearOptions) {
+                        var options = getOptions();
+                        if (!$container) { getContainer(options); }
+                        if (!clearToast($toastElement, options, clearOptions)) {
+                            clearContainer(options);
+                        }
+                    }
+
+                    function remove($toastElement) {
+                        var options = getOptions();
+                        if (!$container) { getContainer(options); }
+                        if ($toastElement && $(':focus', $toastElement).length === 0) {
+                            removeToast($toastElement);
+                            return;
+                        }
+                        if ($container.children().length) {
+                            $container.remove();
+                        }
+                    }
+
+                    // internal functions
+
+                    function clearContainer (options) {
+                        var toastsToClear = $container.children();
+                        for (var i = toastsToClear.length - 1; i >= 0; i--) {
+                            clearToast($(toastsToClear[i]), options);
+                        }
+                    }
+
+                    function clearToast ($toastElement, options, clearOptions) {
+                        var force = clearOptions && clearOptions.force ? clearOptions.force : false;
+                        if ($toastElement && (force || $(':focus', $toastElement).length === 0)) {
+                            $toastElement[options.hideMethod]({
+                                duration: options.hideDuration,
+                                easing: options.hideEasing,
+                                complete: function () { removeToast($toastElement); }
+                            });
+                            return true;
+                        }
+                        return false;
+                    }
+
+                    function createContainer(options) {
+                        $container = $('<div/>')
+                            .attr('id', options.containerId)
+                            .addClass(options.positionClass)
+                            .attr('aria-live', 'polite')
+                            .attr('role', 'alert');
+
+                        $container.appendTo(FintaChart.HtmlContainer.container);
+                        return $container;
+                    }
+
+                    function getDefaults() {
+                        return {
+                            tapToDismiss: true,
+                            toastClass: 'toast',
+                            containerId: 'toast-container',
+                            debug: false,
+
+                            showMethod: 'fadeIn', //fadeIn, slideDown, and show are built into jQuery
+                            showDuration: 300,
+                            showEasing: 'swing', //swing and linear are built into jQuery
+                            onShown: undefined,
+                            hideMethod: 'fadeOut',
+                            hideDuration: 1000,
+                            hideEasing: 'swing',
+                            onHidden: undefined,
+
+                            extendedTimeOut: 1000,
+                            iconClasses: {
+                                error: 'toast-error',
+                                info: 'toast-info',
+                                success: 'toast-success',
+                                warning: 'toast-warning'
+                            },
+                            iconClass: 'toast-info',
+                            positionClass: 'toast-top-right',
+                            timeOut: 5000, // Set timeOut and extendedTimeOut to 0 to make it sticky
+                            titleClass: 'toast-title',
+                            messageClass: 'toast-message',
+                            target: 'body',
+                            closeHtml: '<button type="button">&times;</button>',
+                            newestOnTop: true,
+                            preventDuplicates: false,
+                            progressBar: false
+                        };
+                    }
+
+                    function publish(args) {
+                        if (!listener) { return; }
+                        listener(args);
+                    }
+
+                    function notify(map) {
+                        var options = getOptions();
+                        var iconClass = map.iconClass || options.iconClass;
+
+                        if (typeof (map.optionsOverride) !== 'undefined') {
+                            options = $.extend(options, map.optionsOverride);
+                            iconClass = map.optionsOverride.iconClass || iconClass;
+                        }
+
+                        if (shouldExit(options, map)) { return; }
+
+                        toastId++;
+
+                        $container = getContainer(options, true);
+
+                        var intervalId = null;
+                        var $toastElement = $('<div/>');
+                        var $titleElement = $('<div/>');
+                        var $messageElement = $('<div/>');
+                        var $progressElement = $('<div/>');
+                        var $closeElement = $(options.closeHtml);
+                        var progressBar = {
+                            intervalId: null,
+                            hideEta: null,
+                            maxHideTime: null
+                        };
+                        var response = {
+                            toastId: toastId,
+                            state: 'visible',
+                            startTime: new Date(),
+                            options: options,
+                            map: map
+                        };
+
+                        personalizeToast();
+
+                        displayToast();
+
+                        handleEvents();
+
+                        publish(response);
+
+                        if (options.debug && console) {
+                            console.log(response);
+                        }
+
+                        return $toastElement;
+
+                        function personalizeToast() {
+                            setIcon();
+                            setTitle();
+                            setMessage();
+                            setCloseButton();
+                            setProgressBar();
+                            setSequence();
+                        }
+
+                        function handleEvents() {
+                            $toastElement.hover(stickAround, delayedHideToast);
+                            if (!options.onclick && options.tapToDismiss) {
+                                $toastElement.click(hideToast);
+                            }
+
+                            if (options.closeButton && $closeElement) {
+                                $closeElement.click(function (event) {
+                                    if (event.stopPropagation) {
+                                        event.stopPropagation();
+                                    } else if (event.cancelBubble !== undefined && event.cancelBubble !== true) {
+                                        event.cancelBubble = true;
+                                    }
+                                    hideToast(true);
+                                });
+                            }
+
+                            if (options.onclick) {
+                                $toastElement.click(function () {
+                                    options.onclick();
+                                    hideToast();
+                                });
+                            }
+                        }
+
+                        function displayToast() {
+                            $toastElement.hide();
+
+                            $toastElement[options.showMethod](
+                                {duration: options.showDuration, easing: options.showEasing, complete: options.onShown}
+                            );
+
+                            if (options.timeOut > 0) {
+                                intervalId = setTimeout(hideToast, options.timeOut);
+                                progressBar.maxHideTime = parseFloat(options.timeOut);
+                                progressBar.hideEta = new Date().getTime() + progressBar.maxHideTime;
+                                if (options.progressBar) {
+                                    progressBar.intervalId = setInterval(updateProgress, 10);
+                                }
+                            }
+                        }
+
+                        function setIcon() {
+                            if (map.iconClass) {
+                                $toastElement.addClass(options.toastClass).addClass(iconClass);
+                            }
+                        }
+
+                        function setSequence() {
+                            if (options.newestOnTop) {
+                                $container.prepend($toastElement);
+                            } else {
+                                $container.append($toastElement);
+                            }
+                        }
+
+                        function setTitle() {
+                            if (map.title) {
+                                $titleElement.append(map.title).addClass(options.titleClass);
+                                $toastElement.append($titleElement);
+                            }
+                        }
+
+                        function setMessage() {
+                            if (map.message) {
+                                $messageElement.append(map.message).addClass(options.messageClass);
+                                $toastElement.append($messageElement);
+                            }
+                        }
+
+                        function setCloseButton() {
+                            if (options.closeButton) {
+                                $closeElement.addClass('toast-close-button').attr('role', 'button');
+                                $toastElement.prepend($closeElement);
+                            }
+                        }
+
+                        function setProgressBar() {
+                            if (options.progressBar) {
+                                $progressElement.addClass('toast-progress');
+                                $toastElement.prepend($progressElement);
+                            }
+                        }
+
+                        function shouldExit(options, map) {
+                            if (options.preventDuplicates) {
+                                if (map.message === previousToast) {
+                                    return true;
+                                } else {
+                                    previousToast = map.message;
+                                }
+                            }
+                            return false;
+                        }
+
+                        function hideToast(override) {
+                            if ($(':focus', $toastElement).length && !override) {
+                                return;
+                            }
+                            clearTimeout(progressBar.intervalId);
+                            return $toastElement[options.hideMethod]({
+                                duration: options.hideDuration,
+                                easing: options.hideEasing,
+                                complete: function () {
+                                    removeToast($toastElement);
+                                    if (options.onHidden && response.state !== 'hidden') {
+                                        options.onHidden();
+                                    }
+                                    response.state = 'hidden';
+                                    response.endTime = new Date();
+                                    publish(response);
+                                }
+                            });
+                        }
+
+                        function delayedHideToast() {
+                            if (options.timeOut > 0 || options.extendedTimeOut > 0) {
+                                intervalId = setTimeout(hideToast, options.extendedTimeOut);
+                                progressBar.maxHideTime = parseFloat(options.extendedTimeOut);
+                                progressBar.hideEta = new Date().getTime() + progressBar.maxHideTime;
+                            }
+                        }
+
+                        function stickAround() {
+                            clearTimeout(intervalId);
+                            progressBar.hideEta = 0;
+                            $toastElement.stop(true, true)[options.showMethod](
+                                {duration: options.showDuration, easing: options.showEasing}
+                            );
+                        }
+
+                        function updateProgress() {
+                            var percentage = ((progressBar.hideEta - (new Date().getTime())) / progressBar.maxHideTime) * 100;
+                            $progressElement.width(percentage + '%');
+                        }
+                    }
+
+                    function getOptions() {
+                        return $.extend({}, getDefaults(), toastr.options);
+                    }
+
+                    function removeToast($toastElement) {
+                        if (!$container) { $container = getContainer(); }
+                        if ($toastElement.is(':visible')) {
+                            return;
+                        }
+                        $toastElement.remove();
+                        $toastElement = null;
+                        if ($container.children().length === 0) {
+                            $container.remove();
+                            previousToast = undefined;
+                        }
+                    }
+
+                })();
+            });
+        }(typeof define === 'function' && define.amd ? define : function (deps, factory) {
+            if (typeof module !== 'undefined' && module.exports) { //Node
+                module.exports = factory(require('jquery'));
+            } else {
+                window['toastr'] = factory(window['jQuery']);
+            }
+        }));
+
+    })(External = FintaChart.External || (FintaChart.External = {}));
+})(FintaChart || (FintaChart = {}));
+
+

package/scripts/jsdataadapters/fileDataAdapter.js

@@ -0,0 +1,129 @@
+/*
+    IMPORTANT NOTICE: This software and source code is owned and licensed by Fintatech B.V., https://fintatech.com
+    Downloading, installing or otherwise using this software or source code shall be made only under Fintatech License
+    agreement. If you do not granted Fintatech License agreement, you must promptly delete the software,
+    source code and all associated downloadable materials and you must not use the software for any purpose whatsoever.
+*/
+
+'use strict';
+
+var fileDatafeed = new FintaChart.FileDatafeed({
+  instruments: {
+
+    'EUR/GBP': {
+      instrument: {
+        symbol: 'EUR/GBP',
+        exchange: 'FOREX',
+        type: "FOREX",
+        company: '',
+        tickSize: 0.00001,
+      },
+      info: [
+
+        {
+          interval: 1,
+          periodicity: '',
+          path: 'data/offline-market-history/EUR_GBP/Minute/1.csv',
+        },
+        {
+          interval: 1,
+          periodicity: 'h',
+          path: 'data/offline-market-history/EUR_GBP/Hour/1.csv',
+        },
+        {
+          interval: 1,
+          periodicity: 'd',
+          path: 'data/offline-market-history/EUR_GBP/Day/1.csv',
+        },
+        {
+          interval: 1,
+          periodicity: 'w',
+          path: 'data/offline-market-history/EUR_GBP/Weekly/1.csv',
+        },
+        {
+          interval: 1,
+          periodicity: 'm',
+          path: 'data/offline-market-history/EUR_GBP/Monthly/1.csv',
+        },
+        {
+          interval: 1,
+          periodicity: 'y',
+          path: 'data/offline-market-history/EUR_GBP/Yearly/1.csv',
+        },
+        {
+          interval: 4,
+          periodicity: 'h',
+          path: 'data/offline-market-history/EUR_GBP/Hour/4.csv',
+        },
+        {
+          interval: 5,
+          periodicity: '',
+          path: 'data/offline-market-history/EUR_GBP/Minute/5.csv',
+        },
+        {
+          interval: 15,
+          periodicity: '',
+          path: 'data/offline-market-history/EUR_GBP/Minute/15.csv',
+        },
+      ],
+    },
+    'EUR/CAD': {
+      instrument: {
+        symbol: 'EUR/CAD',
+        exchange: 'FOREX',
+        type: "FOREX",
+        company: '',
+        tickSize: 0.00001,
+      },
+      info: [
+
+        {
+          interval: 1,
+          periodicity: '',
+          path: 'data/offline-market-history/EUR_CAD/Minute/1.csv',
+        },
+        {
+          interval: 1,
+          periodicity: 'h',
+          path: 'data/offline-market-history/EUR_CAD/Hour/1.csv',
+        },
+        {
+          interval: 1,
+          periodicity: 'd',
+          path: 'data/offline-market-history/EUR_CAD/Day/1.csv',
+        },
+        {
+          interval: 1,
+          periodicity: 'w',
+          path: 'data/offline-market-history/EUR_CAD/Weekly/1.csv',
+        },
+        {
+          interval: 1,
+          periodicity: 'm',
+          path: 'data/offline-market-history/EUR_CAD/Monthly/1.csv',
+        },
+        {
+          interval: 1,
+          periodicity: 'y',
+          path: 'data/offline-market-history/EUR_CAD/Yearly/1.csv',
+        },
+        {
+          interval: 4,
+          periodicity: 'h',
+          path: 'data/offline-market-history/EUR_CAD/Hour/4.csv',
+        },
+        {
+          interval: 5,
+          periodicity: '',
+          path: 'data/offline-market-history/EUR_CAD/Minute/5.csv',
+        },
+        {
+          interval: 15,
+          periodicity: '',
+          path: 'data/offline-market-history/EUR_CAD/Minute/15.csv',
+        },
+      ],
+    },
+  },
+  externalDataFormatter: new FintaChart.Formatters.ExternalDataFormatterCsv(),
+});

package/scripts/jsdataadapters/restDataAdapter.js

@@ -0,0 +1,149 @@
+/*
+    IMPORTANT NOTICE: This software and source code is owned and licensed by Fintatech B.V., https://fintatech.com
+    Downloading, installing or otherwise using this software or source code shall be made only under Fintatech License
+    agreement. If you do not granted Fintatech License agreement, you must promptly delete the software,
+    source code and all associated downloadable materials and you must not use the software for any purpose whatsoever.
+*/
+
+'use strict';
+
+var restDatafeed = new FintaChart.RestDatafeed('http://developerwindows001.fintatech.com:5005/api', 6000);
+
+restDatafeed.requestFormatter = {
+    formatGetLastTick: (name, exchange) => {
+        var customHeaders = new Headers();
+        customHeaders.append("Content-Type", "application/json");
+        var fetchInit = {
+            method: 'POST',
+            headers: customHeaders,
+            mode: 'cors',
+            cache: 'default',
+            body: JSON.stringify({
+                instrument: {
+                    name: name,
+                    exchange: exchange,
+                },
+            }),
+        };
+
+        return {
+            path: `/lasttick`,
+            config: fetchInit,
+        }
+    },
+    formatGetInstruments: () => {
+        var customHeaders = new Headers();
+        customHeaders.append("Content-Type", "application/json");
+
+        var fetchInit = {
+            method: 'POST',
+            headers: customHeaders,
+            mode: 'cors',
+            cache: 'default',
+            body: JSON.stringify({
+                maxCount: 0,
+            }),
+        };
+
+        return {
+            path: `/instruments`,
+            config: fetchInit,
+        }
+    },
+    formatGetHistory: (request) => {
+        var customHeaders = new Headers();
+        customHeaders.append("Content-Type", "application/json");
+
+        let requestBody = {
+            params: {
+                interval: request.chart.timeFrame.interval,
+                periodicity: periodicityConvert(request.chart.timeFrame.periodicity),
+                direction: 0,
+                barsCount: request.count,
+            },
+            instrument: {
+                name: request.instrument.symbol || request.chart.instrument.symbol,
+                exchange: request.instrument.exchange || request.chart.instrument.exchange,
+            },
+        };
+
+        if (request.endDate) {
+            requestBody.params.endDate = request.endDate.getTime()
+        }
+
+        var fetchInit = {
+            method: 'POST',
+            headers: customHeaders,
+            mode: 'cors',
+            cache: 'default',
+            body: JSON.stringify(requestBody),
+        };
+
+        return {
+            path: `/history`,
+            config: fetchInit,
+        }
+    },
+};
+
+restDatafeed.responseFormatter = {
+    formatInstruments: (response) => {
+        if (response.Instruments) {
+            return response.Instruments.map(item => {
+                let result = {};
+                result.symbol = item.Name;
+                result.company = '';
+                result.exchange = item.Exchange;
+                result.tickSize = item.TickSize ? item.TickSize : 0.01;
+                return result;
+            });
+        }
+    },
+    formatBars: (response) => {
+        if (response.Data) {
+            return response.Data.map(item => {
+                return {
+                    date: new Date(item.TimeStamp), //parse from unix time in miliseconds, e.g. 1522403929000
+                    open: item.Open, //e.g. 1.344636
+                    high: item.High, //e.g. 1.344636
+                    low: item.Low, //e.g. 1.344636
+                    close: item.Close, //e.g. 1.344636
+                    volume: item.Volume, //e.g. 56754
+                };
+            });
+        }
+    },
+    formatRealtime: (response) => {
+        if (response.Tick) {
+            return {
+                symbol: response.Tick.Instrument.Name, //e.g. 'AAPL'
+                ask: response.Tick.Ask, //e.g. 2.123125
+                bid: response.Tick.Bid, //e.g. 2.123125
+                bidSize: response.Tick.BidSize, //e.g. 12
+                askSize: response.Tick.AskSize, //e.g. 15
+                volume: response.Tick.Volume, //e.g. 10
+                price: response.Tick.Price, //e.g. 1.344636
+                timeStamp: response.Tick.TimeStamp, //unix time in miliseconds, e.g. 1522403929000
+            };
+        }
+    },
+};
+
+function periodicityConvert(input) {
+    switch (input) {
+        case 't':
+            return 0;
+        case '':
+            return 1;
+        case 'h':
+            return 2;
+        case 'd':
+            return 3;
+        case 'w':
+            return 4;
+        case 'm':
+            return 5;
+        case 'y':
+            return 6;
+    }
+}