binbot-charts 0.0.19 → 0.0.22

package/public/datafeeds/udf/src/symbols-storage.ts

@@ -1,298 +0,0 @@
-import {
-	LibrarySymbolInfo,
-	SearchSymbolResultItem,
-	ResolutionString,
-} from '../../../charting_library/datafeed-api';
-
-import {
-	getErrorMessage,
-	logMessage,
-} from './helpers';
-
-import { Requester } from './requester';
-
-interface SymbolInfoMap {
-	[symbol: string]: LibrarySymbolInfo | undefined;
-}
-
-interface ExchangeDataResponseSymbolData {
-	'type': string;
-	'timezone': LibrarySymbolInfo['timezone'];
-	'description': string;
-
-	'exchange-listed': string;
-	'exchange-traded': string;
-
-	'session-regular': string;
-	'corrections'?: string;
-	'session-holidays'?: string;
-
-	'fractional': boolean;
-
-	'pricescale': number;
-
-	'ticker'?: string;
-
-	'minmov2'?: number;
-	'minmove2'?: number;
-
-	'minmov'?: number;
-	'minmovement'?: number;
-
-	'supported-resolutions'?: ResolutionString[];
-	'intraday-multipliers'?: string[];
-
-	'has-intraday'?: boolean;
-	'has-daily'?: boolean;
-	'has-weekly-and-monthly'?: boolean;
-	'has-empty-bars'?: boolean;
-	'has-no-volume'?: boolean;
-	'currency-code'?: string;
-	'original-currency-code'?: string;
-	'unit-id'?: string;
-	'original-unit-id'?: string;
-	'unit-conversion-types'?: string[];
-
-	'volume-precision'?: number;
-}
-
-// Here is some black magic with types to get compile-time checks of names and types
-type PickArrayedObjectFields<T> = Pick<T, {
-	// tslint:disable-next-line:no-any
-	[K in keyof T]-?: NonNullable<T[K]> extends any[] ? K : never;
-}[keyof T]>;
-
-type ExchangeDataResponseArrayedSymbolData = PickArrayedObjectFields<ExchangeDataResponseSymbolData>;
-type ExchangeDataResponseNonArrayedSymbolData = Pick<ExchangeDataResponseSymbolData, Exclude<keyof ExchangeDataResponseSymbolData, keyof ExchangeDataResponseArrayedSymbolData>>;
-
-type ExchangeDataResponse =
-	{
-		symbol: string[];
-	} &
-	{
-		[K in keyof ExchangeDataResponseSymbolData]: ExchangeDataResponseSymbolData[K] | NonNullable<ExchangeDataResponseSymbolData[K]>[];
-	};
-
-function extractField<Field extends keyof ExchangeDataResponseNonArrayedSymbolData>(data: ExchangeDataResponse, field: Field, arrayIndex: number): ExchangeDataResponseNonArrayedSymbolData[Field];
-function extractField<Field extends keyof ExchangeDataResponseArrayedSymbolData>(data: ExchangeDataResponse, field: Field, arrayIndex: number, valueIsArray: true): ExchangeDataResponseArrayedSymbolData[Field];
-function extractField<Field extends keyof ExchangeDataResponseSymbolData>(data: ExchangeDataResponse, field: Field, arrayIndex: number, valueIsArray?: boolean): ExchangeDataResponseSymbolData[Field] {
-	const value: ExchangeDataResponse[keyof ExchangeDataResponseSymbolData] = data[field];
-
-	if (Array.isArray(value) && (!valueIsArray || Array.isArray(value[0]))) {
-		return value[arrayIndex] as ExchangeDataResponseSymbolData[Field];
-	}
-
-	return value as ExchangeDataResponseSymbolData[Field];
-}
-
-function symbolKey(symbol: string, currency?: string, unit?: string): string {
-	// 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 {
-	private readonly _exchangesList: string[] = ['NYSE', 'FOREX', 'AMEX'];
-	private readonly _symbolsInfo: SymbolInfoMap = {};
-	private readonly _symbolsList: string[] = [];
-	private readonly _datafeedUrl: string;
-	private readonly _readyPromise: Promise<void>;
-	private readonly _datafeedSupportedResolutions: ResolutionString[];
-	private readonly _requester: Requester;
-
-	public constructor(datafeedUrl: string, datafeedSupportedResolutions: ResolutionString[], requester: Requester) {
-		this._datafeedUrl = datafeedUrl;
-		this._datafeedSupportedResolutions = datafeedSupportedResolutions;
-		this._requester = requester;
-		this._readyPromise = this._init();
-		this._readyPromise.catch((error: 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
-	public resolveSymbol(symbolName: string, currencyCode?: string, unitId?: string): Promise<LibrarySymbolInfo> {
-		return this._readyPromise.then(() => {
-			const symbolInfo = this._symbolsInfo[symbolKey(symbolName, currencyCode, unitId)];
-			if (symbolInfo === undefined) {
-				return Promise.reject('invalid symbol');
-			}
-
-			return Promise.resolve(symbolInfo);
-		});
-	}
-
-	public searchSymbols(searchString: string, exchange: string, symbolType: string, maxSearchResults: number): Promise<SearchSymbolResultItem[]> {
-		interface WeightedItem {
-			symbolInfo: LibrarySymbolInfo;
-			weight: number;
-		}
-
-		return this._readyPromise.then(() => {
-			const weightedResult: WeightedItem[] = [];
-			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: WeightedItem) => item.symbolInfo === symbolInfo);
-					if (!alreadyExists) {
-						const weight = positionInName >= 0 ? positionInName : 8000 + positionInDescription;
-						weightedResult.push({ symbolInfo: symbolInfo, weight: weight });
-					}
-				}
-			}
-
-			const result = weightedResult
-				.sort((item1: WeightedItem, item2: WeightedItem) => item1.weight - item2.weight)
-				.slice(0, maxSearchResults)
-				.map((item: WeightedItem) => {
-					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);
-		});
-	}
-
-	private _init(): Promise<void> {
-		interface BooleanMap {
-			[key: string]: boolean | undefined;
-		}
-
-		const promises: Promise<void>[] = [];
-		const alreadyRequestedExchanges: BooleanMap = {};
-
-		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');
-			});
-	}
-
-	private _requestExchangeData(exchange: string): Promise<void> {
-		return new Promise((resolve: () => void, reject: (error: Error) => void) => {
-			this._requester.sendRequest<ExchangeDataResponse>(this._datafeedUrl, 'symbol_info', { group: exchange })
-				.then((response: ExchangeDataResponse) => {
-					try {
-						this._onExchangeDataReceived(exchange, response);
-					} catch (error) {
-						reject(error);
-						return;
-					}
-
-					resolve();
-				})
-				.catch((reason?: string | Error) => {
-					logMessage(`SymbolsStorage: Request data for exchange '${exchange}' failed, reason=${getErrorMessage(reason)}`);
-					resolve();
-				});
-		});
-	}
-
-	private _onExchangeDataReceived(exchange: string, data: ExchangeDataResponse): void {
-		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) as string) : symbolName;
-
-				const symbolInfo: LibrarySymbolInfo = {
-					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<T>(value: T | undefined, defaultValue: T): T {
-	return value !== undefined ? value : defaultValue;
-}

package/public/datafeeds/udf/src/udf-compatible-datafeed-base.ts

@@ -1,369 +0,0 @@
-import {
-	DatafeedConfiguration,
-	ErrorCallback,
-	GetMarksCallback,
-	HistoryCallback,
-	IDatafeedChartApi,
-	IDatafeedQuotesApi,
-	IExternalDatafeed,
-	LibrarySymbolInfo,
-	Mark,
-	OnReadyCallback,
-	QuotesCallback,
-	ResolutionString,
-	ResolveCallback,
-	SearchSymbolResultItem,
-	SearchSymbolsCallback,
-	ServerTimeCallback,
-	SubscribeBarsCallback,
-	TimescaleMark,
-	SymbolResolveExtension,
-} from '../../../charting_library/datafeed-api';
-
-import {
-	getErrorMessage,
-	logMessage,
-	RequestParams,
-	UdfErrorResponse,
-} from './helpers';
-
-import {
-	GetBarsResult,
-	HistoryProvider,
-	PeriodParamsWithOptionalCountback,
-} from './history-provider';
-
-import { IQuotesProvider } from './iquotes-provider';
-import { DataPulseProvider } from './data-pulse-provider';
-import { QuotesPulseProvider } from './quotes-pulse-provider';
-import { SymbolsStorage } from './symbols-storage';
-import { Requester } from './requester';
-
-export interface UdfCompatibleConfiguration extends DatafeedConfiguration {
-	// tslint:disable:tv-variable-name
-	supports_search?: boolean;
-	supports_group_request?: boolean;
-	// tslint:enable:tv-variable-name
-}
-
-export interface ResolveSymbolResponse extends LibrarySymbolInfo {
-	s: undefined;
-}
-
-// it is hack to let's TypeScript make code flow analysis
-export interface UdfSearchSymbolsResponse extends Array<SearchSymbolResultItem> {
-	s?: undefined;
-}
-
-export const enum Constants {
-	SearchItemsLimit = 30,
-}
-
-type UdfDatafeedMarkType<T extends TimescaleMark | Mark> = {
-	[K in keyof T]: T[K] | T[K][];
-} & {
-	id: (string | number)[];
-};
-
-type UdfDatafeedMark = UdfDatafeedMarkType<Mark>;
-type UdfDatafeedTimescaleMark = UdfDatafeedMarkType<TimescaleMark>;
-
-function extractField<Field extends keyof Mark>(data: UdfDatafeedMark, field: Field, arrayIndex: number): Mark[Field];
-function extractField<Field extends keyof TimescaleMark>(data: UdfDatafeedTimescaleMark, field: Field, arrayIndex: number): TimescaleMark[Field];
-function extractField<T, TField extends keyof T>(data: T, field: TField, arrayIndex: number): T[TField] {
-	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 implements IExternalDatafeed, IDatafeedQuotesApi, IDatafeedChartApi {
-	protected _configuration: UdfCompatibleConfiguration = defaultConfiguration();
-	private readonly _datafeedURL: string;
-	private readonly _configurationReadyPromise: Promise<void>;
-
-	private _symbolsStorage: SymbolsStorage | null = null;
-
-	private readonly _historyProvider: HistoryProvider;
-	private readonly _dataPulseProvider: DataPulseProvider;
-
-	private readonly _quotesProvider: IQuotesProvider;
-	private readonly _quotesPulseProvider: QuotesPulseProvider;
-
-	private readonly _requester: Requester;
-
-	protected constructor(datafeedURL: string, quotesProvider: IQuotesProvider, requester: Requester, updateFrequency: number = 10 * 1000) {
-		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: UdfCompatibleConfiguration | null) => {
-				if (configuration === null) {
-					configuration = defaultConfiguration();
-				}
-
-				this._setupWithConfiguration(configuration);
-			});
-	}
-
-	public onReady(callback: OnReadyCallback): void {
-		this._configurationReadyPromise.then(() => {
-			callback(this._configuration);
-		});
-	}
-
-	public getQuotes(symbols: string[], onDataCallback: QuotesCallback, onErrorCallback: (msg: string) => void): void {
-		this._quotesProvider.getQuotes(symbols).then(onDataCallback).catch(onErrorCallback);
-	}
-
-	public subscribeQuotes(symbols: string[], fastSymbols: string[], onRealtimeCallback: QuotesCallback, listenerGuid: string): void {
-		this._quotesPulseProvider.subscribeQuotes(symbols, fastSymbols, onRealtimeCallback, listenerGuid);
-	}
-
-	public unsubscribeQuotes(listenerGuid: string): void {
-		this._quotesPulseProvider.unsubscribeQuotes(listenerGuid);
-	}
-
-	public getMarks(symbolInfo: LibrarySymbolInfo, from: number, to: number, onDataCallback: GetMarksCallback<Mark>, resolution: ResolutionString): void {
-		if (!this._configuration.supports_marks) {
-			return;
-		}
-
-		const requestParams: RequestParams = {
-			symbol: symbolInfo.ticker || '',
-			from: from,
-			to: to,
-			resolution: resolution,
-		};
-
-		this._send<Mark[] | UdfDatafeedMark>('marks', requestParams)
-			.then((response: Mark[] | UdfDatafeedMark) => {
-				if (!Array.isArray(response)) {
-					const result: Mark[] = [];
-					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?: string | Error) => {
-				logMessage(`UdfCompatibleDatafeed: Request marks failed: ${getErrorMessage(error)}`);
-				onDataCallback([]);
-			});
-	}
-
-	public getTimescaleMarks(symbolInfo: LibrarySymbolInfo, from: number, to: number, onDataCallback: GetMarksCallback<TimescaleMark>, resolution: ResolutionString): void {
-		if (!this._configuration.supports_timescale_marks) {
-			return;
-		}
-
-		const requestParams: RequestParams = {
-			symbol: symbolInfo.ticker || '',
-			from: from,
-			to: to,
-			resolution: resolution,
-		};
-
-		this._send<TimescaleMark[] | UdfDatafeedTimescaleMark>('timescale_marks', requestParams)
-			.then((response: TimescaleMark[] | UdfDatafeedTimescaleMark) => {
-				if (!Array.isArray(response)) {
-					const result: TimescaleMark[] = [];
-					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?: string | Error) => {
-				logMessage(`UdfCompatibleDatafeed: Request timescale marks failed: ${getErrorMessage(error)}`);
-				onDataCallback([]);
-			});
-	}
-
-	public getServerTime(callback: ServerTimeCallback): void {
-		if (!this._configuration.supports_time) {
-			return;
-		}
-
-		this._send<string>('time')
-			.then((response: string) => {
-				const time = parseInt(response);
-				if (!isNaN(time)) {
-					callback(time);
-				}
-			})
-			.catch((error?: string | Error) => {
-				logMessage(`UdfCompatibleDatafeed: Fail to load server time, error=${getErrorMessage(error)}`);
-			});
-	}
-
-	public searchSymbols(userInput: string, exchange: string, symbolType: string, onResult: SearchSymbolsCallback): void {
-		if (this._configuration.supports_search) {
-			const params: RequestParams = {
-				limit: Constants.SearchItemsLimit,
-				query: userInput.toUpperCase(),
-				type: symbolType,
-				exchange: exchange,
-			};
-
-			this._send<UdfSearchSymbolsResponse | UdfErrorResponse>('search', params)
-				.then((response: UdfSearchSymbolsResponse | UdfErrorResponse) => {
-					if (response.s !== undefined) {
-						logMessage(`UdfCompatibleDatafeed: search symbols error=${response.errmsg}`);
-						onResult([]);
-						return;
-					}
-
-					onResult(response);
-				})
-				.catch((reason?: string | Error) => {
-					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, Constants.SearchItemsLimit)
-				.then(onResult)
-				.catch(onResult.bind(null, []));
-		}
-	}
-
-	public resolveSymbol(symbolName: string, onResolve: ResolveCallback, onError: ErrorCallback, extension?: SymbolResolveExtension): void {
-		logMessage('Resolve requested');
-
-		const currencyCode = extension && extension.currencyCode;
-		const unitId = extension && extension.unitId;
-
-		const resolveRequestStartTime = Date.now();
-		function onResultReady(symbolInfo: LibrarySymbolInfo): void {
-			logMessage(`Symbol resolved: ${Date.now() - resolveRequestStartTime}ms`);
-			onResolve(symbolInfo);
-		}
-
-		if (!this._configuration.supports_group_request) {
-			const params: RequestParams = {
-				symbol: symbolName,
-			};
-			if (currencyCode !== undefined) {
-				params.currencyCode = currencyCode;
-			}
-			if (unitId !== undefined) {
-				params.unitId = unitId;
-			}
-
-			this._send<ResolveSymbolResponse | UdfErrorResponse>('symbols', params)
-				.then((response: ResolveSymbolResponse | UdfErrorResponse) => {
-					if (response.s !== undefined) {
-						onError('unknown_symbol');
-					} else {
-						onResultReady(response);
-					}
-				})
-				.catch((reason?: string | Error) => {
-					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);
-		}
-	}
-
-	public getBars(symbolInfo: LibrarySymbolInfo, resolution: ResolutionString, periodParams: PeriodParamsWithOptionalCountback, onResult: HistoryCallback, onError: ErrorCallback): void {
-		this._historyProvider.getBars(symbolInfo, resolution, periodParams)
-			.then((result: GetBarsResult) => {
-				onResult(result.bars, result.meta);
-			})
-			.catch(onError);
-	}
-
-	public subscribeBars(symbolInfo: LibrarySymbolInfo, resolution: ResolutionString, onTick: SubscribeBarsCallback, listenerGuid: string, onResetCacheNeededCallback: () => void): void {
-		this._dataPulseProvider.subscribeBars(symbolInfo, resolution, onTick, listenerGuid);
-	}
-
-	public unsubscribeBars(listenerGuid: string): void {
-		this._dataPulseProvider.unsubscribeBars(listenerGuid);
-	}
-
-	protected _requestConfiguration(): Promise<UdfCompatibleConfiguration | null> {
-		return this._send<UdfCompatibleConfiguration>('config')
-			.catch((reason?: string | Error) => {
-				logMessage(`UdfCompatibleDatafeed: Cannot get datafeed configuration - use default, error=${getErrorMessage(reason)}`);
-				return null;
-			});
-	}
-
-	private _send<T>(urlPath: string, params?: RequestParams): Promise<T> {
-		return this._requester.sendRequest<T>(this._datafeedURL, urlPath, params);
-	}
-
-	private _setupWithConfiguration(configurationData: UdfCompatibleConfiguration): void {
-		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(): UdfCompatibleConfiguration {
-	return {
-		supports_search: false,
-		supports_group_request: true,
-		supported_resolutions: [
-			'1' as ResolutionString,
-			'5' as ResolutionString,
-			'15' as ResolutionString,
-			'30' as ResolutionString,
-			'60' as ResolutionString,
-			'1D' as ResolutionString,
-			'1W' as ResolutionString,
-			'1M' as ResolutionString,
-		],
-		supports_marks: false,
-		supports_timescale_marks: false,
-	};
-}

package/public/datafeeds/udf/src/udf-compatible-datafeed.ts

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

package/public/datafeeds/udf/tsconfig.json

@@ -1,25 +0,0 @@
-{
-	"compilerOptions": {
-		"allowSyntheticDefaultImports": true,
-		"importHelpers": true,
-		"lib": [
-			"dom",
-			"es2018"
-		],
-		"module": "es6",
-		"moduleResolution": "node",
-		"noEmitOnError": true,
-		"noFallthroughCasesInSwitch": true,
-		"noImplicitReturns": true,
-		"noUnusedLocals": true,
-		"outDir": "./lib/",
-		"rootDir": "src",
-		"sourceMap": false,
-		"strict": true,
-		"target": "es2018",
-		"types": []
-	},
-	"include": [
-		"./src/**/*.ts"
-	]
-}