binbot-charts 0.0.1

package/public/datafeeds/udf/lib/helpers.js

@@ -0,0 +1,20 @@
+/**
+ * If you want to enable logs from datafeed set it to `true`
+ */
+const isLoggingEnabled = false;
+export function logMessage(message) {
+    if (isLoggingEnabled) {
+        const now = new Date();
+        // tslint:disable-next-line:no-console
+        console.log(`${now.toLocaleTimeString()}.${now.getMilliseconds()}> ${message}`);
+    }
+}
+export function getErrorMessage(error) {
+    if (error === undefined) {
+        return '';
+    }
+    else if (typeof error === 'string') {
+        return error;
+    }
+    return error.message;
+}

package/public/datafeeds/udf/lib/history-provider.js

@@ -0,0 +1,73 @@
+import { getErrorMessage, } from './helpers';
+export class HistoryProvider {
+    constructor(datafeedUrl, requester) {
+        this._datafeedUrl = datafeedUrl;
+        this._requester = requester;
+    }
+    getBars(symbolInfo, resolution, periodParams) {
+        const requestParams = {
+            symbol: symbolInfo.ticker || '',
+            resolution: resolution,
+            from: periodParams.from,
+            to: periodParams.to,
+        };
+        if (periodParams.countBack !== undefined) {
+            requestParams.countback = periodParams.countBack;
+        }
+        if (symbolInfo.currency_code !== undefined) {
+            requestParams.currencyCode = symbolInfo.currency_code;
+        }
+        if (symbolInfo.unit_id !== undefined) {
+            requestParams.unitId = symbolInfo.unit_id;
+        }
+        return new Promise((resolve, reject) => {
+            this._requester.sendRequest(this._datafeedUrl, 'history', requestParams)
+                .then((response) => {
+                if (response.s !== 'ok' && response.s !== 'no_data') {
+                    reject(response.errmsg);
+                    return;
+                }
+                const bars = [];
+                const meta = {
+                    noData: false,
+                };
+                if (response.s === 'no_data') {
+                    meta.noData = true;
+                    meta.nextTime = response.nextTime;
+                }
+                else {
+                    const volumePresent = response.v !== undefined;
+                    const ohlPresent = response.o !== undefined;
+                    for (let i = 0; i < response.t.length; ++i) {
+                        const barValue = {
+                            time: response.t[i] * 1000,
+                            close: parseFloat(response.c[i]),
+                            open: parseFloat(response.c[i]),
+                            high: parseFloat(response.c[i]),
+                            low: parseFloat(response.c[i]),
+                        };
+                        if (ohlPresent) {
+                            barValue.open = parseFloat(response.o[i]);
+                            barValue.high = parseFloat(response.h[i]);
+                            barValue.low = parseFloat(response.l[i]);
+                        }
+                        if (volumePresent) {
+                            barValue.volume = parseFloat(response.v[i]);
+                        }
+                        bars.push(barValue);
+                    }
+                }
+                resolve({
+                    bars: bars,
+                    meta: meta,
+                });
+            })
+                .catch((reason) => {
+                const reasonString = getErrorMessage(reason);
+                // tslint:disable-next-line:no-console
+                console.warn(`HistoryProvider: getBars() failed, error=${reasonString}`);
+                reject(reasonString);
+            });
+        });
+    }
+}

package/public/datafeeds/udf/lib/iquotes-provider.js

@@ -0,0 +1 @@
+export {};

package/public/datafeeds/udf/lib/quotes-provider.js

@@ -0,0 +1,25 @@
+import { getErrorMessage, logMessage, } from './helpers';
+export class QuotesProvider {
+    constructor(datafeedUrl, requester) {
+        this._datafeedUrl = datafeedUrl;
+        this._requester = requester;
+    }
+    getQuotes(symbols) {
+        return new Promise((resolve, reject) => {
+            this._requester.sendRequest(this._datafeedUrl, 'quotes', { symbols: symbols })
+                .then((response) => {
+                if (response.s === 'ok') {
+                    resolve(response.d);
+                }
+                else {
+                    reject(response.errmsg);
+                }
+            })
+                .catch((error) => {
+                const errorMessage = getErrorMessage(error);
+                logMessage(`QuotesProvider: getQuotes failed, error=${errorMessage}`);
+                reject(`network error: ${errorMessage}`);
+            });
+        });
+    }
+}

package/public/datafeeds/udf/lib/quotes-pulse-provider.js

@@ -0,0 +1,44 @@
+import { getErrorMessage, logMessage, } from './helpers';
+export class QuotesPulseProvider {
+    constructor(quotesProvider) {
+        this._subscribers = {};
+        this._requestsPending = 0;
+        this._quotesProvider = quotesProvider;
+        setInterval(this._updateQuotes.bind(this, 1 /* Fast */), 10000 /* Fast */);
+        setInterval(this._updateQuotes.bind(this, 0 /* General */), 60000 /* General */);
+    }
+    subscribeQuotes(symbols, fastSymbols, onRealtimeCallback, listenerGuid) {
+        this._subscribers[listenerGuid] = {
+            symbols: symbols,
+            fastSymbols: fastSymbols,
+            listener: onRealtimeCallback,
+        };
+        logMessage(`QuotesPulseProvider: subscribed quotes with #${listenerGuid}`);
+    }
+    unsubscribeQuotes(listenerGuid) {
+        delete this._subscribers[listenerGuid];
+        logMessage(`QuotesPulseProvider: unsubscribed quotes with #${listenerGuid}`);
+    }
+    _updateQuotes(updateType) {
+        if (this._requestsPending > 0) {
+            return;
+        }
+        for (const listenerGuid in this._subscribers) { // tslint:disable-line:forin
+            this._requestsPending++;
+            const subscriptionRecord = this._subscribers[listenerGuid];
+            this._quotesProvider.getQuotes(updateType === 1 /* Fast */ ? subscriptionRecord.fastSymbols : subscriptionRecord.symbols)
+                .then((data) => {
+                this._requestsPending--;
+                if (!this._subscribers.hasOwnProperty(listenerGuid)) {
+                    return;
+                }
+                subscriptionRecord.listener(data);
+                logMessage(`QuotesPulseProvider: data for #${listenerGuid} (${updateType}) updated successfully, pending=${this._requestsPending}`);
+            })
+                .catch((reason) => {
+                this._requestsPending--;
+                logMessage(`QuotesPulseProvider: data for #${listenerGuid} (${updateType}) updated with error=${getErrorMessage(reason)}, pending=${this._requestsPending}`);
+            });
+        }
+    }
+}

package/public/datafeeds/udf/lib/requester.js

@@ -0,0 +1,28 @@
+import { logMessage } from './helpers';
+export class Requester {
+    constructor(headers) {
+        if (headers) {
+            this._headers = headers;
+        }
+    }
+    sendRequest(datafeedUrl, urlPath, params) {
+        if (params !== undefined) {
+            const paramKeys = Object.keys(params);
+            if (paramKeys.length !== 0) {
+                urlPath += '?';
+            }
+            urlPath += paramKeys.map((key) => {
+                return `${encodeURIComponent(key)}=${encodeURIComponent(params[key].toString())}`;
+            }).join('&');
+        }
+        logMessage('New request: ' + urlPath);
+        // Send user cookies if the URL is on the same origin as the calling script.
+        const options = { credentials: 'same-origin' };
+        if (this._headers !== undefined) {
+            options.headers = this._headers;
+        }
+        return fetch(`${datafeedUrl}/${urlPath}`, options)
+            .then((response) => response.text())
+            .then((responseTest) => JSON.parse(responseTest));
+    }
+}

package/public/datafeeds/udf/lib/symbols-storage.js

@@ -0,0 +1,180 @@
+import { getErrorMessage, logMessage, } from './helpers';
+function extractField(data, field, arrayIndex, valueIsArray) {
+    const value = data[field];
+    if (Array.isArray(value) && (!valueIsArray || Array.isArray(value[0]))) {
+        return value[arrayIndex];
+    }
+    return value;
+}
+function symbolKey(symbol, currency, unit) {
+    // here we're using a separator that quite possible shouldn't be in a real symbol name
+    return symbol + (currency !== undefined ? '_%|#|%_' + currency : '') + (unit !== undefined ? '_%|#|%_' + unit : '');
+}
+export class SymbolsStorage {
+    constructor(datafeedUrl, datafeedSupportedResolutions, requester) {
+        this._exchangesList = ['NYSE', 'FOREX', 'AMEX'];
+        this._symbolsInfo = {};
+        this._symbolsList = [];
+        this._datafeedUrl = datafeedUrl;
+        this._datafeedSupportedResolutions = datafeedSupportedResolutions;
+        this._requester = requester;
+        this._readyPromise = this._init();
+        this._readyPromise.catch((error) => {
+            // seems it is impossible
+            // tslint:disable-next-line:no-console
+            console.error(`SymbolsStorage: Cannot init, error=${error.toString()}`);
+        });
+    }
+    // BEWARE: this function does not consider symbol's exchange
+    resolveSymbol(symbolName, currencyCode, unitId) {
+        return this._readyPromise.then(() => {
+            const symbolInfo = this._symbolsInfo[symbolKey(symbolName, currencyCode, unitId)];
+            if (symbolInfo === undefined) {
+                return Promise.reject('invalid symbol');
+            }
+            return Promise.resolve(symbolInfo);
+        });
+    }
+    searchSymbols(searchString, exchange, symbolType, maxSearchResults) {
+        return this._readyPromise.then(() => {
+            const weightedResult = [];
+            const queryIsEmpty = searchString.length === 0;
+            searchString = searchString.toUpperCase();
+            for (const symbolName of this._symbolsList) {
+                const symbolInfo = this._symbolsInfo[symbolName];
+                if (symbolInfo === undefined) {
+                    continue;
+                }
+                if (symbolType.length > 0 && symbolInfo.type !== symbolType) {
+                    continue;
+                }
+                if (exchange && exchange.length > 0 && symbolInfo.exchange !== exchange) {
+                    continue;
+                }
+                const positionInName = symbolInfo.name.toUpperCase().indexOf(searchString);
+                const positionInDescription = symbolInfo.description.toUpperCase().indexOf(searchString);
+                if (queryIsEmpty || positionInName >= 0 || positionInDescription >= 0) {
+                    const alreadyExists = weightedResult.some((item) => item.symbolInfo === symbolInfo);
+                    if (!alreadyExists) {
+                        const weight = positionInName >= 0 ? positionInName : 8000 + positionInDescription;
+                        weightedResult.push({ symbolInfo: symbolInfo, weight: weight });
+                    }
+                }
+            }
+            const result = weightedResult
+                .sort((item1, item2) => item1.weight - item2.weight)
+                .slice(0, maxSearchResults)
+                .map((item) => {
+                const symbolInfo = item.symbolInfo;
+                return {
+                    symbol: symbolInfo.name,
+                    full_name: symbolInfo.full_name,
+                    description: symbolInfo.description,
+                    exchange: symbolInfo.exchange,
+                    params: [],
+                    type: symbolInfo.type,
+                    ticker: symbolInfo.name,
+                };
+            });
+            return Promise.resolve(result);
+        });
+    }
+    _init() {
+        const promises = [];
+        const alreadyRequestedExchanges = {};
+        for (const exchange of this._exchangesList) {
+            if (alreadyRequestedExchanges[exchange]) {
+                continue;
+            }
+            alreadyRequestedExchanges[exchange] = true;
+            promises.push(this._requestExchangeData(exchange));
+        }
+        return Promise.all(promises)
+            .then(() => {
+            this._symbolsList.sort();
+            logMessage('SymbolsStorage: All exchanges data loaded');
+        });
+    }
+    _requestExchangeData(exchange) {
+        return new Promise((resolve, reject) => {
+            this._requester.sendRequest(this._datafeedUrl, 'symbol_info', { group: exchange })
+                .then((response) => {
+                try {
+                    this._onExchangeDataReceived(exchange, response);
+                }
+                catch (error) {
+                    reject(error);
+                    return;
+                }
+                resolve();
+            })
+                .catch((reason) => {
+                logMessage(`SymbolsStorage: Request data for exchange '${exchange}' failed, reason=${getErrorMessage(reason)}`);
+                resolve();
+            });
+        });
+    }
+    _onExchangeDataReceived(exchange, data) {
+        let symbolIndex = 0;
+        try {
+            const symbolsCount = data.symbol.length;
+            const tickerPresent = data.ticker !== undefined;
+            for (; symbolIndex < symbolsCount; ++symbolIndex) {
+                const symbolName = data.symbol[symbolIndex];
+                const listedExchange = extractField(data, 'exchange-listed', symbolIndex);
+                const tradedExchange = extractField(data, 'exchange-traded', symbolIndex);
+                const fullName = tradedExchange + ':' + symbolName;
+                const currencyCode = extractField(data, 'currency-code', symbolIndex);
+                const unitId = extractField(data, 'unit-id', symbolIndex);
+                const ticker = tickerPresent ? extractField(data, 'ticker', symbolIndex) : symbolName;
+                const symbolInfo = {
+                    ticker: ticker,
+                    name: symbolName,
+                    base_name: [listedExchange + ':' + symbolName],
+                    full_name: fullName,
+                    listed_exchange: listedExchange,
+                    exchange: tradedExchange,
+                    currency_code: currencyCode,
+                    original_currency_code: extractField(data, 'original-currency-code', symbolIndex),
+                    unit_id: unitId,
+                    original_unit_id: extractField(data, 'original-unit-id', symbolIndex),
+                    unit_conversion_types: extractField(data, 'unit-conversion-types', symbolIndex, true),
+                    description: extractField(data, 'description', symbolIndex),
+                    has_intraday: definedValueOrDefault(extractField(data, 'has-intraday', symbolIndex), false),
+                    has_no_volume: definedValueOrDefault(extractField(data, 'has-no-volume', symbolIndex), false),
+                    minmov: extractField(data, 'minmovement', symbolIndex) || extractField(data, 'minmov', symbolIndex) || 0,
+                    minmove2: extractField(data, 'minmove2', symbolIndex) || extractField(data, 'minmov2', symbolIndex),
+                    fractional: extractField(data, 'fractional', symbolIndex),
+                    pricescale: extractField(data, 'pricescale', symbolIndex),
+                    type: extractField(data, 'type', symbolIndex),
+                    session: extractField(data, 'session-regular', symbolIndex),
+                    session_holidays: extractField(data, 'session-holidays', symbolIndex),
+                    corrections: extractField(data, 'corrections', symbolIndex),
+                    timezone: extractField(data, 'timezone', symbolIndex),
+                    supported_resolutions: definedValueOrDefault(extractField(data, 'supported-resolutions', symbolIndex, true), this._datafeedSupportedResolutions),
+                    has_daily: definedValueOrDefault(extractField(data, 'has-daily', symbolIndex), true),
+                    intraday_multipliers: definedValueOrDefault(extractField(data, 'intraday-multipliers', symbolIndex, true), ['1', '5', '15', '30', '60']),
+                    has_weekly_and_monthly: extractField(data, 'has-weekly-and-monthly', symbolIndex),
+                    has_empty_bars: extractField(data, 'has-empty-bars', symbolIndex),
+                    volume_precision: definedValueOrDefault(extractField(data, 'volume-precision', symbolIndex), 0),
+                    format: 'price',
+                };
+                this._symbolsInfo[ticker] = symbolInfo;
+                this._symbolsInfo[symbolName] = symbolInfo;
+                this._symbolsInfo[fullName] = symbolInfo;
+                if (currencyCode !== undefined || unitId !== undefined) {
+                    this._symbolsInfo[symbolKey(ticker, currencyCode, unitId)] = symbolInfo;
+                    this._symbolsInfo[symbolKey(symbolName, currencyCode, unitId)] = symbolInfo;
+                    this._symbolsInfo[symbolKey(fullName, currencyCode, unitId)] = symbolInfo;
+                }
+                this._symbolsList.push(symbolName);
+            }
+        }
+        catch (error) {
+            throw new Error(`SymbolsStorage: API error when processing exchange ${exchange} symbol #${symbolIndex} (${data.symbol[symbolIndex]}): ${error.message}`);
+        }
+    }
+}
+function definedValueOrDefault(value, defaultValue) {
+    return value !== undefined ? value : defaultValue;
+}

package/public/datafeeds/udf/lib/udf-compatible-datafeed-base.js

@@ -0,0 +1,252 @@
+import { getErrorMessage, logMessage, } from './helpers';
+import { HistoryProvider, } from './history-provider';
+import { DataPulseProvider } from './data-pulse-provider';
+import { QuotesPulseProvider } from './quotes-pulse-provider';
+import { SymbolsStorage } from './symbols-storage';
+function extractField(data, field, arrayIndex) {
+    const value = data[field];
+    return Array.isArray(value) ? value[arrayIndex] : value;
+}
+/**
+ * This class implements interaction with UDF-compatible datafeed.
+ * See UDF protocol reference at https://github.com/tradingview/charting_library/wiki/UDF
+ */
+export class UDFCompatibleDatafeedBase {
+    constructor(datafeedURL, quotesProvider, requester, updateFrequency = 10 * 1000) {
+        this._configuration = defaultConfiguration();
+        this._symbolsStorage = null;
+        this._datafeedURL = datafeedURL;
+        this._requester = requester;
+        this._historyProvider = new HistoryProvider(datafeedURL, this._requester);
+        this._quotesProvider = quotesProvider;
+        this._dataPulseProvider = new DataPulseProvider(this._historyProvider, updateFrequency);
+        this._quotesPulseProvider = new QuotesPulseProvider(this._quotesProvider);
+        this._configurationReadyPromise = this._requestConfiguration()
+            .then((configuration) => {
+            if (configuration === null) {
+                configuration = defaultConfiguration();
+            }
+            this._setupWithConfiguration(configuration);
+        });
+    }
+    onReady(callback) {
+        this._configurationReadyPromise.then(() => {
+            callback(this._configuration);
+        });
+    }
+    getQuotes(symbols, onDataCallback, onErrorCallback) {
+        this._quotesProvider.getQuotes(symbols).then(onDataCallback).catch(onErrorCallback);
+    }
+    subscribeQuotes(symbols, fastSymbols, onRealtimeCallback, listenerGuid) {
+        this._quotesPulseProvider.subscribeQuotes(symbols, fastSymbols, onRealtimeCallback, listenerGuid);
+    }
+    unsubscribeQuotes(listenerGuid) {
+        this._quotesPulseProvider.unsubscribeQuotes(listenerGuid);
+    }
+    getMarks(symbolInfo, from, to, onDataCallback, resolution) {
+        if (!this._configuration.supports_marks) {
+            return;
+        }
+        const requestParams = {
+            symbol: symbolInfo.ticker || '',
+            from: from,
+            to: to,
+            resolution: resolution,
+        };
+        this._send('marks', requestParams)
+            .then((response) => {
+            if (!Array.isArray(response)) {
+                const result = [];
+                for (let i = 0; i < response.id.length; ++i) {
+                    result.push({
+                        id: extractField(response, 'id', i),
+                        time: extractField(response, 'time', i),
+                        color: extractField(response, 'color', i),
+                        text: extractField(response, 'text', i),
+                        label: extractField(response, 'label', i),
+                        labelFontColor: extractField(response, 'labelFontColor', i),
+                        minSize: extractField(response, 'minSize', i),
+                    });
+                }
+                response = result;
+            }
+            onDataCallback(response);
+        })
+            .catch((error) => {
+            logMessage(`UdfCompatibleDatafeed: Request marks failed: ${getErrorMessage(error)}`);
+            onDataCallback([]);
+        });
+    }
+    getTimescaleMarks(symbolInfo, from, to, onDataCallback, resolution) {
+        if (!this._configuration.supports_timescale_marks) {
+            return;
+        }
+        const requestParams = {
+            symbol: symbolInfo.ticker || '',
+            from: from,
+            to: to,
+            resolution: resolution,
+        };
+        this._send('timescale_marks', requestParams)
+            .then((response) => {
+            if (!Array.isArray(response)) {
+                const result = [];
+                for (let i = 0; i < response.id.length; ++i) {
+                    result.push({
+                        id: extractField(response, 'id', i),
+                        time: extractField(response, 'time', i),
+                        color: extractField(response, 'color', i),
+                        label: extractField(response, 'label', i),
+                        tooltip: extractField(response, 'tooltip', i),
+                    });
+                }
+                response = result;
+            }
+            onDataCallback(response);
+        })
+            .catch((error) => {
+            logMessage(`UdfCompatibleDatafeed: Request timescale marks failed: ${getErrorMessage(error)}`);
+            onDataCallback([]);
+        });
+    }
+    getServerTime(callback) {
+        if (!this._configuration.supports_time) {
+            return;
+        }
+        this._send('time')
+            .then((response) => {
+            const time = parseInt(response);
+            if (!isNaN(time)) {
+                callback(time);
+            }
+        })
+            .catch((error) => {
+            logMessage(`UdfCompatibleDatafeed: Fail to load server time, error=${getErrorMessage(error)}`);
+        });
+    }
+    searchSymbols(userInput, exchange, symbolType, onResult) {
+        if (this._configuration.supports_search) {
+            const params = {
+                limit: 30 /* SearchItemsLimit */,
+                query: userInput.toUpperCase(),
+                type: symbolType,
+                exchange: exchange,
+            };
+            this._send('search', params)
+                .then((response) => {
+                if (response.s !== undefined) {
+                    logMessage(`UdfCompatibleDatafeed: search symbols error=${response.errmsg}`);
+                    onResult([]);
+                    return;
+                }
+                onResult(response);
+            })
+                .catch((reason) => {
+                logMessage(`UdfCompatibleDatafeed: Search symbols for '${userInput}' failed. Error=${getErrorMessage(reason)}`);
+                onResult([]);
+            });
+        }
+        else {
+            if (this._symbolsStorage === null) {
+                throw new Error('UdfCompatibleDatafeed: inconsistent configuration (symbols storage)');
+            }
+            this._symbolsStorage.searchSymbols(userInput, exchange, symbolType, 30 /* SearchItemsLimit */)
+                .then(onResult)
+                .catch(onResult.bind(null, []));
+        }
+    }
+    resolveSymbol(symbolName, onResolve, onError, extension) {
+        logMessage('Resolve requested');
+        const currencyCode = extension && extension.currencyCode;
+        const unitId = extension && extension.unitId;
+        const resolveRequestStartTime = Date.now();
+        function onResultReady(symbolInfo) {
+            logMessage(`Symbol resolved: ${Date.now() - resolveRequestStartTime}ms`);
+            onResolve(symbolInfo);
+        }
+        if (!this._configuration.supports_group_request) {
+            const params = {
+                symbol: symbolName,
+            };
+            if (currencyCode !== undefined) {
+                params.currencyCode = currencyCode;
+            }
+            if (unitId !== undefined) {
+                params.unitId = unitId;
+            }
+            this._send('symbols', params)
+                .then((response) => {
+                if (response.s !== undefined) {
+                    onError('unknown_symbol');
+                }
+                else {
+                    onResultReady(response);
+                }
+            })
+                .catch((reason) => {
+                logMessage(`UdfCompatibleDatafeed: Error resolving symbol: ${getErrorMessage(reason)}`);
+                onError('unknown_symbol');
+            });
+        }
+        else {
+            if (this._symbolsStorage === null) {
+                throw new Error('UdfCompatibleDatafeed: inconsistent configuration (symbols storage)');
+            }
+            this._symbolsStorage.resolveSymbol(symbolName, currencyCode, unitId).then(onResultReady).catch(onError);
+        }
+    }
+    getBars(symbolInfo, resolution, periodParams, onResult, onError) {
+        this._historyProvider.getBars(symbolInfo, resolution, periodParams)
+            .then((result) => {
+            onResult(result.bars, result.meta);
+        })
+            .catch(onError);
+    }
+    subscribeBars(symbolInfo, resolution, onTick, listenerGuid, onResetCacheNeededCallback) {
+        this._dataPulseProvider.subscribeBars(symbolInfo, resolution, onTick, listenerGuid);
+    }
+    unsubscribeBars(listenerGuid) {
+        this._dataPulseProvider.unsubscribeBars(listenerGuid);
+    }
+    _requestConfiguration() {
+        return this._send('config')
+            .catch((reason) => {
+            logMessage(`UdfCompatibleDatafeed: Cannot get datafeed configuration - use default, error=${getErrorMessage(reason)}`);
+            return null;
+        });
+    }
+    _send(urlPath, params) {
+        return this._requester.sendRequest(this._datafeedURL, urlPath, params);
+    }
+    _setupWithConfiguration(configurationData) {
+        this._configuration = configurationData;
+        if (configurationData.exchanges === undefined) {
+            configurationData.exchanges = [];
+        }
+        if (!configurationData.supports_search && !configurationData.supports_group_request) {
+            throw new Error('Unsupported datafeed configuration. Must either support search, or support group request');
+        }
+        if (configurationData.supports_group_request || !configurationData.supports_search) {
+            this._symbolsStorage = new SymbolsStorage(this._datafeedURL, configurationData.supported_resolutions || [], this._requester);
+        }
+        logMessage(`UdfCompatibleDatafeed: Initialized with ${JSON.stringify(configurationData)}`);
+    }
+}
+function defaultConfiguration() {
+    return {
+        supports_search: false,
+        supports_group_request: true,
+        supported_resolutions: [
+            '1',
+            '5',
+            '15',
+            '30',
+            '60',
+            '1D',
+            '1W',
+            '1M',
+        ],
+        supports_marks: false,
+        supports_timescale_marks: false,
+    };
+}

package/public/datafeeds/udf/lib/udf-compatible-datafeed.js

@@ -0,0 +1,10 @@
+import { UDFCompatibleDatafeedBase } from './udf-compatible-datafeed-base';
+import { QuotesProvider } from './quotes-provider';
+import { Requester } from './requester';
+export class UDFCompatibleDatafeed extends UDFCompatibleDatafeedBase {
+    constructor(datafeedURL, updateFrequency = 10 * 1000) {
+        const requester = new Requester();
+        const quotesProvider = new QuotesProvider(datafeedURL, requester);
+        super(datafeedURL, quotesProvider, requester, updateFrequency);
+    }
+}

package/public/datafeeds/udf/package.json

@@ -0,0 +1,17 @@
+{
+  "private": true,
+  "dependencies": {
+    "tslib": "2.3.0"
+  },
+  "devDependencies": {
+    "@rollup/plugin-node-resolve": "~9.0.0",
+    "rollup": "~2.28.2",
+    "rollup-plugin-terser": "~7.0.2",
+    "typescript": "4.3.5"
+  },
+  "scripts": {
+    "compile": "tsc",
+    "bundle-js": "rollup -c rollup.config.js",
+    "build": "npm run compile && npm run bundle-js"
+  }
+}