---

import { BehaviorSubject, Subscription } from 'rxjs';

import { Chart } from '@core/Chart';
import { Intervals } from '@src/types/intervals';

interface ChartInternals {
  eventManager: {
    symbolId: () => BehaviorSubject<string>;
    getInterval: () => BehaviorSubject<Intervals | null>;
    getTimeframe: jest.Mock;
  };
  compareManager: {
    itemsObs: () => BehaviorSubject<{ symbolId: string }[]>;
  };
  dataSource: {
    setSymbols: jest.Mock;
    loadTill: jest.Mock;
    loadAllHistory: jest.Mock;
    loadMoreHistory: jest.Mock;
    getOldestTime: jest.Mock;
    getLastCandle: jest.Mock;
  };
  lwcChart: {
    timeScale: () => {
      getVisibleRange: jest.Mock;
      setVisibleRange: jest.Mock;
      getVisibleLogicalRange: jest.Mock;
    };
  };
  mouseEvents: {
    subscribe: jest.Mock;
  };
  paneManager: {
    setVisibleLogicalRange: jest.Mock;
  };
  subscriptions: Subscription;
  activeSymbolIds: string[];
  historyBatchRunning: boolean;
  setupDataSourceSubs: () => void;
  setupHistoricalDataLoading: () => void;
  scheduleHistoryBatch: () => void;
}

interface CreateChartOptions {
  symbolId?: string;
  interval?: Intervals | null;
  compareSymbolIds?: string[];
}

interface ChartTestContext {
  chart: ChartInternals;
  symbolId$: BehaviorSubject<string>;
  interval$: BehaviorSubject<Intervals | null>;
  getTimeframe: jest.Mock;
  compareItems$: BehaviorSubject<{ symbolId: string }[]>;
  setSymbols: jest.Mock;
  loadTill: jest.Mock;
  loadAllHistory: jest.Mock;
  loadMoreHistory: jest.Mock;
  getOldestTime: jest.Mock;
  getLastCandle: jest.Mock;
  getVisibleRange: jest.Mock;
  getVisibleLogicalRange: jest.Mock;
  setVisibleRange: jest.Mock;
  mouseEventsSubscribe: jest.Mock;
  setVisibleLogicalRange: jest.Mock;
}

interface Deferred {
  promise: Promise<void>;
  resolve: () => void;
}

function createDeferred(): Deferred {
  let resolve!: () => void;

  const promise = new Promise<void>((resolver) => {
    resolve = resolver;
  });

  return {
    promise,
    resolve,
  };
}

async function flushPromises(): Promise<void> {
  await Promise.resolve();
  await Promise.resolve();
  await Promise.resolve();
}

describe('Chart', () => {
  let animationFrameCallbacks: FrameRequestCallback[];

  beforeEach(() => {
    animationFrameCallbacks = [];

    jest.spyOn(window, 'requestAnimationFrame').mockImplementation((callback) => {
      animationFrameCallbacks.push(callback);

      return animationFrameCallbacks.length;
    });
  });

  afterEach(() => {
    jest.restoreAllMocks();
  });

  function runNextAnimationFrame(): void {
    const callback = animationFrameCallbacks.shift();

    callback?.(0);
  }

  function createChartInternals({
    symbolId = '',
    interval = null,
    compareSymbolIds = ['SBER', 'SBER'],
  }: CreateChartOptions = {}): ChartTestContext {
    const symbolId$ = new BehaviorSubject(symbolId);
    const interval$ = new BehaviorSubject<Intervals | null>(interval);
    const compareItems$ = new BehaviorSubject(
      compareSymbolIds.map((value) => ({
        symbolId: value,
      })),
    );

    const setSymbols = jest.fn();
    const loadTill = jest.fn(() => Promise.resolve());
    const loadAllHistory = jest.fn(() => Promise.resolve());
    const loadMoreHistory = jest.fn(() => Promise.resolve());
    const getOldestTime = jest.fn(() => 100);
    const getLastCandle = jest.fn(() => ({ time: 200 }));
    const getVisibleRange = jest.fn(() => null);
    const getVisibleLogicalRange = jest.fn(() => ({ from: 0, to: 1000 }));
    const setVisibleRange = jest.fn();
    const getTimeframe = jest.fn(() => '1m');
    const mouseEventsSubscribe = jest.fn();
    const setVisibleLogicalRange = jest.fn();

    const chart = Object.assign(Object.create(Chart.prototype), {
      eventManager: {
        symbolId: () => symbolId$,
        getInterval: () => interval$,
        getTimeframe,
      },
      compareManager: {
        itemsObs: () => compareItems$,
      },
      dataSource: {
        setSymbols,
        loadTill,
        loadAllHistory,
        loadMoreHistory,
        getOldestTime,
        getLastCandle,
      },
      lwcChart: {
        timeScale: () => ({
          getVisibleRange,
          getVisibleLogicalRange,
          setVisibleRange,
        }),
      },
      mouseEvents: {
        subscribe: mouseEventsSubscribe,
      },
      paneManager: {
        setVisibleLogicalRange,
      },
      subscriptions: new Subscription(),
      activeSymbolIds: [],
      historyBatchRunning: false,
    }) as ChartInternals;

    return {
      chart,
      symbolId$,
      interval$,
      getTimeframe,
      compareItems$,
      setSymbols,
      loadTill,
      loadAllHistory,
      loadMoreHistory,
      getOldestTime,
      getLastCandle,
      getVisibleRange,
      getVisibleLogicalRange,
      setVisibleRange,
      mouseEventsSubscribe,
      setVisibleLogicalRange,
    };
  }

  it('должен исключать пустой основной symbolId и удалять дубликаты', () => {
    const { chart, setSymbols } = createChartInternals();

    chart.setupDataSourceSubs();

    expect(setSymbols).toHaveBeenCalledTimes(1);
    expect(setSymbols).toHaveBeenCalledWith(['SBER']);

    chart.subscriptions.unsubscribe();
  });

  it('должен зарегистрировать символ до загрузки данных начального интервала', () => {
    const callOrder: string[] = [];

    const { chart, setSymbols, loadTill } = createChartInternals({
      symbolId: 'SBER',
      compareSymbolIds: [],
      interval: Intervals['1Y'],
    });

    setSymbols.mockImplementation(() => {
      callOrder.push('setSymbols');
    });

    loadTill.mockImplementation(() => {
      callOrder.push('loadTill');

      return Promise.resolve();
    });

    chart.setupDataSourceSubs();

    expect(callOrder).toEqual(['setSymbols', 'loadTill']);

    chart.subscriptions.unsubscribe();
  });

  it('должен применить начальный интервал после загрузки данных', async () => {
    const { chart, loadTill, setVisibleRange } = createChartInternals({
      symbolId: 'SBER',
      compareSymbolIds: [],
      interval: Intervals['1Y'],
    });

    chart.setupDataSourceSubs();

    expect(loadTill).toHaveBeenCalledTimes(1);
    expect(loadTill).toHaveBeenCalledWith('SBER', expect.any(Number));

    await flushPromises();

    expect(setVisibleRange).toHaveBeenCalledTimes(1);
    expect(setVisibleRange).toHaveBeenCalledWith({
      from: expect.any(Number),
      to: expect.any(Number),
    });

    chart.subscriptions.unsubscribe();
  });

  it('не должен применять интервал при отсутствии данных', async () => {
    const { chart, getOldestTime, setVisibleRange } = createChartInternals({
      symbolId: 'SBER',
      compareSymbolIds: [],
      interval: Intervals['1Y'],
    });

    getOldestTime.mockReturnValue(null);

    chart.setupDataSourceSubs();

    await flushPromises();

    expect(setVisibleRange).not.toHaveBeenCalled();

    chart.subscriptions.unsubscribe();
  });

  it('не должен применять результат устаревшего интервала', async () => {
    const firstLoad = createDeferred();
    const secondLoad = createDeferred();

    const { chart, interval$, loadTill, loadAllHistory, setVisibleRange } = createChartInternals({
      symbolId: 'SBER',
      compareSymbolIds: [],
      interval: Intervals['1Y'],
    });

    loadTill.mockReturnValue(firstLoad.promise);
    loadAllHistory.mockReturnValue(secondLoad.promise);

    chart.setupDataSourceSubs();

    expect(loadTill).toHaveBeenCalledTimes(1);

    interval$.next(Intervals.All);

    expect(loadAllHistory).toHaveBeenCalledTimes(1);

    secondLoad.resolve();

    await flushPromises();

    expect(setVisibleRange).toHaveBeenCalledTimes(1);
    expect(setVisibleRange).toHaveBeenCalledWith({
      from: 100,
      to: 200,
    });

    firstLoad.resolve();

    await flushPromises();

    expect(setVisibleRange).toHaveBeenCalledTimes(1);

    chart.subscriptions.unsubscribe();
  });

  it('не должен повторно регистрировать символы при смене только интервала', () => {
    const { chart, interval$, setSymbols } = createChartInternals({
      symbolId: 'SBER',
      compareSymbolIds: [],
      interval: Intervals['1Y'],
    });

    chart.setupDataSourceSubs();

    expect(setSymbols).toHaveBeenCalledTimes(1);

    interval$.next(Intervals.All);

    expect(setSymbols).toHaveBeenCalledTimes(1);
    expect(setSymbols).toHaveBeenCalledWith(['SBER']);

    chart.subscriptions.unsubscribe();
  });

  it('должен зарегистрировать новый основной символ и применить к нему активный интервал', async () => {
    const { chart, symbolId$, setSymbols, loadTill } = createChartInternals({
      symbolId: 'SBER',
      compareSymbolIds: [],
      interval: Intervals['1Y'],
    });

    chart.setupDataSourceSubs();

    await flushPromises();

    setSymbols.mockClear();
    loadTill.mockClear();

    symbolId$.next('GAZP');

    expect(setSymbols).toHaveBeenCalledTimes(1);
    expect(setSymbols).toHaveBeenCalledWith(['GAZP']);

    expect(loadTill).toHaveBeenCalledTimes(1);
    expect(loadTill).toHaveBeenCalledWith('GAZP', expect.any(Number));

    chart.subscriptions.unsubscribe();
  });

  it('должен загрузить всю историю для интервала All и применить общий диапазон', async () => {
    const { chart, loadAllHistory, getOldestTime, getLastCandle, setVisibleRange } = createChartInternals({
      symbolId: 'SBER',
      compareSymbolIds: ['GAZP'],
      interval: Intervals.All,
    });

    getOldestTime.mockImplementation((symbolId: string) => (symbolId === 'SBER' ? 100 : 50));

    getLastCandle.mockImplementation((symbolId: string) => ({
      time: symbolId === 'SBER' ? 200 : 300,
    }));

    chart.setupDataSourceSubs();

    expect(loadAllHistory).toHaveBeenCalledTimes(2);
    expect(loadAllHistory).toHaveBeenCalledWith('SBER');
    expect(loadAllHistory).toHaveBeenCalledWith('GAZP');

    await flushPromises();

    expect(setVisibleRange).toHaveBeenCalledTimes(1);
    expect(setVisibleRange).toHaveBeenCalledWith({
      from: 50,
      to: 300,
    });

    chart.subscriptions.unsubscribe();
  });

  it('должен прогреть добавленный символ при отсутствии активного интервала', async () => {
    const { chart, getVisibleRange, loadTill } = createChartInternals({
      symbolId: 'SBER',
      compareSymbolIds: [],
      interval: null,
    });

    getVisibleRange.mockReturnValue({
      from: 100,
      to: 200,
    });

    chart.setupDataSourceSubs();

    expect(loadTill).toHaveBeenCalledTimes(1);
    expect(loadTill).toHaveBeenCalledWith('SBER', 100);

    await flushPromises();

    chart.subscriptions.unsubscribe();
  });

  it('не должен применять интервал после отписки', async () => {
    const loading = createDeferred();

    const { chart, loadTill, setVisibleRange } = createChartInternals({
      symbolId: 'SBER',
      compareSymbolIds: [],
      interval: Intervals['1Y'],
    });

    loadTill.mockReturnValue(loading.promise);

    chart.setupDataSourceSubs();

    expect(loadTill).toHaveBeenCalledTimes(1);

    chart.subscriptions.unsubscribe();

    loading.resolve();

    await flushPromises();

    expect(setVisibleRange).not.toHaveBeenCalled();
  });

  it('не должен повторно догружать историю, если старейшая свеча не изменилась', async () => {
    const { chart, loadMoreHistory, getOldestTime, getVisibleLogicalRange } = createChartInternals({
      symbolId: 'SBER',
      compareSymbolIds: [],
    });

    chart.activeSymbolIds = ['SBER'];
    getOldestTime.mockReturnValue(100);

    chart.scheduleHistoryBatch();
    runNextAnimationFrame();

    await flushPromises();

    expect(loadMoreHistory).toHaveBeenCalledTimes(1);
    expect(getVisibleLogicalRange).not.toHaveBeenCalled();
    expect(animationFrameCallbacks).toHaveLength(0);
  });

  it('должен продолжить догрузку истории, если старейшая свеча сдвинулась назад', async () => {
    const { chart, loadMoreHistory, getOldestTime, getVisibleLogicalRange } = createChartInternals({
      symbolId: 'SBER',
      compareSymbolIds: [],
    });

    let oldestTime = 100;

    chart.activeSymbolIds = ['SBER'];

    getOldestTime.mockImplementation(() => oldestTime);

    loadMoreHistory.mockImplementation(() => {
      oldestTime = 90;

      return Promise.resolve();
    });

    chart.scheduleHistoryBatch();
    runNextAnimationFrame();

    await flushPromises();

    expect(loadMoreHistory).toHaveBeenCalledTimes(1);
    expect(getVisibleLogicalRange).toHaveBeenCalledTimes(1);
    expect(animationFrameCallbacks).toHaveLength(1);
  });

  it('должен считать появление первой старейшей свечи прогрессом', async () => {
    const { chart, loadMoreHistory, getOldestTime } = createChartInternals({
      symbolId: 'SBER',
      compareSymbolIds: [],
    });

    let oldestTime: number | null = null;

    chart.activeSymbolIds = ['SBER'];

    getOldestTime.mockImplementation(() => oldestTime);

    loadMoreHistory.mockImplementation(() => {
      oldestTime = 100;

      return Promise.resolve();
    });

    chart.scheduleHistoryBatch();
    runNextAnimationFrame();

    await flushPromises();

    expect(animationFrameCallbacks).toHaveLength(1);
  });

  it('не должен останавливать новую цепочку загрузки при смене символа во время запроса', async () => {
    const loading = createDeferred();

    const { chart, loadMoreHistory, getOldestTime } = createChartInternals({
      symbolId: 'SBER',
      compareSymbolIds: [],
    });

    chart.activeSymbolIds = ['SBER'];

    getOldestTime.mockImplementation((symbolId: string) => (symbolId === 'SBER' ? 100 : 200));

    loadMoreHistory.mockReturnValue(loading.promise);

    chart.scheduleHistoryBatch();
    runNextAnimationFrame();

    chart.activeSymbolIds = ['GAZP'];

    loading.resolve();

    await flushPromises();

    expect(animationFrameCallbacks).toHaveLength(1);
  });

  it('не должен останавливать новую цепочку загрузки при смене таймфрейма во время запроса', async () => {
    const loading = createDeferred();

    const { chart, getTimeframe, loadMoreHistory, getOldestTime } = createChartInternals({
      symbolId: 'SBER',
      compareSymbolIds: [],
    });

    let timeframe = '1m';

    chart.activeSymbolIds = ['SBER'];

    getTimeframe.mockImplementation(() => timeframe);
    getOldestTime.mockReturnValue(100);
    loadMoreHistory.mockReturnValue(loading.promise);

    chart.scheduleHistoryBatch();
    runNextAnimationFrame();

    timeframe = '5m';

    loading.resolve();

    await flushPromises();

    expect(animationFrameCallbacks).toHaveLength(1);
  });

  it('должен запускать фоновую догрузку для интервала All', async () => {
    const { chart, loadMoreHistory, mouseEventsSubscribe, setVisibleLogicalRange } = createChartInternals({
      symbolId: 'SBER',
      compareSymbolIds: [],
      interval: Intervals.All,
    });

    chart.setupDataSourceSubs();
    chart.setupHistoricalDataLoading();

    const visibleLogicalRangeChangeHandler = mouseEventsSubscribe.mock.calls[0][1] as (
      logicalRange: { from: number; to: number } | null,
    ) => void;

    visibleLogicalRangeChangeHandler({ from: 0, to: 1000 });

    expect(setVisibleLogicalRange).toHaveBeenCalledWith({ from: 0, to: 1000 });
    expect(animationFrameCallbacks).toHaveLength(1);

    runNextAnimationFrame();

    await flushPromises();

    expect(loadMoreHistory).toHaveBeenCalledTimes(1);
    expect(animationFrameCallbacks).toHaveLength(0);

    chart.subscriptions.unsubscribe();
  });
});
















import dayjs from 'dayjs';

import {
  BarPrice,
  ChartOptions,
  createChart,
  CrosshairMode,
  DeepPartial,
  IChartApi,
  IRange,
  LocalizationOptionsBase,
  LogicalRange,
  Time,
  UTCTimestamp,
} from 'lightweight-charts';

import { BehaviorSubject, combineLatest, defer, EMPTY, Observable, Subscription } from 'rxjs';
import { catchError, distinctUntilChanged, filter, ignoreElements, map, switchMap, tap } from 'rxjs/operators';

import { ChartMouseEvents } from '@core/ChartMouseEvents';
import { DataSource } from '@core/DataSource';
import { DOMModel } from '@core/DOMModel';
import { DrawingsManagerCollection } from '@core/DrawingsManagerCollection';
import { EventManager } from '@core/EventManager';
import { Hotkeys } from '@core/Hotkeys';
import { IndicatorManager } from '@core/IndicatorManager';
import { ModalRenderer } from '@core/ModalRenderer';
import { PaneManager } from '@core/PaneManager';
import { CHART_PANE_LEGEND_CONTAINER } from '@src/constants';
import { CompareManager } from '@src/core/CompareManager';
import { SeriesStrategies } from '@src/modules/series-strategies/SeriesFactory';
import { getThemeStore } from '@src/theme/store';
import { ThemeKey, ThemeMode } from '@src/theme/types';
import { getLocale } from '@src/translations';
import {
  Candle,
  ChartOptionsModel,
  ChartSeriesType,
  ChartTypeOptions,
  Direction,
  OHLCConfig,
  TooltipConfig,
} from '@src/types';
import { Defaults } from '@src/types/defaults';
import { DayjsOffset, Intervals, intervalsToDayjs } from '@src/types/intervals';
import { ChartSnapshot, CompareSnapshot, IndicatorSnapshot, ISerializable, PaneSnapshot } from '@src/types/snapshot';
import { canvasToBlob, drawTextLayer, formatCompactNumber } from '@src/utils';
import { createTickMarkFormatter, formatDate } from '@src/utils/formatter';

export interface ChartConfig extends Partial<ChartOptionsModel> {
  container: HTMLElement;
  seriesTypes: ChartSeriesType[];
  theme: ThemeKey;
  mode?: ThemeMode;
  chartOptions?: ChartTypeOptions;
  localization?: LocalizationOptionsBase;
}

export enum Resize {
  Shrink,
  Expand,
}

const HISTORY_LOAD_THRESHOLD = 500;

interface ChartParams {
  params: {
    dataSource: DataSource;
    eventManager: EventManager;
    modalRenderer: ModalRenderer;
    ohlcConfig: OHLCConfig;
    tooltipConfig: TooltipConfig;
    panes: PaneSnapshot[];
    hotkeys: Hotkeys;
  };
  lwcChartConfig: ChartConfig;
}

function splitIndicatorSnapshots(panes: PaneSnapshot[]): {
  compareSnapshots: CompareSnapshot[];
  indicatorSnapshots: IndicatorSnapshot[];
} {
  const snapshots = panes.flatMap(({ id, indicators }) =>
    indicators.map((indicator) => ({
      ...indicator,
      paneId: id,
    })),
  );

  function isIndicatorSnapshot(
    input: (IndicatorSnapshot | CompareSnapshot) & { indicatorType?: unknown },
  ): input is IndicatorSnapshot {
    return input.indicatorType !== undefined;
  }

  function isCompareSnapshot(
    input: (IndicatorSnapshot | CompareSnapshot) & { indicatorType?: unknown },
  ): input is CompareSnapshot {
    return input.indicatorType === undefined;
  }

  return {
    indicatorSnapshots: snapshots.filter((snapshot) => isIndicatorSnapshot(snapshot)),
    compareSnapshots: snapshots.filter((snapshot) => isCompareSnapshot(snapshot)),
  };
}

/**
 * Абстракция над библиотекой для построения графиков
 */
export class Chart implements ISerializable<ChartSnapshot> {
  private lwcChart!: IChartApi;
  private container: HTMLElement;
  private eventManager: EventManager;
  private paneManager!: PaneManager;
  private compareManager: CompareManager;
  private mouseEvents: ChartMouseEvents;
  private indicatorManager: IndicatorManager;
  private optionsSubscription: Subscription;
  private dataSource: DataSource;
  private chartConfig: ChartConfig;
  private mainSeries: BehaviorSubject<SeriesStrategies | null>; // Main Series. Exists in a single copy
  private DOM: DOMModel;

  private isPointerDown = false;
  private didResetOnDrag = false;

  private subscriptions = new Subscription();

  private activeSymbolIds: string[] = [];

  private historyBatchRunning = false;

  private active = true;
  private savedViewport: {
    logicalRange: LogicalRange | null;
    timeRange: IRange<Time> | null;
    oldestTimes: (number | null)[];
    shiftVisibleRangeOnNewBar: boolean;
    allowShiftVisibleRangeOnWhitespaceReplacement: boolean;
  } | null = null;

  constructor({ params, lwcChartConfig }: ChartParams) {
    const { eventManager, dataSource, modalRenderer, ohlcConfig, tooltipConfig, panes: panesSnapshot } = params;

    this.eventManager = eventManager;
    this.dataSource = dataSource;
    this.container = lwcChartConfig.container;
    this.chartConfig = lwcChartConfig;

    this.lwcChart = createChart(this.container, getOptions(lwcChartConfig));

    this.optionsSubscription = this.eventManager
      .getChartOptionsModel()
      .subscribe(({ dateFormat, timeFormat, showTime }) => {
        this.chartConfig = {
          ...this.chartConfig,
          dateFormat,
          timeFormat,
          showTime,
        };

        this.lwcChart.applyOptions({
          ...getOptions(this.chartConfig),
          localization: {
            timeFormatter: (time: UTCTimestamp) => formatDate(time, dateFormat, timeFormat, showTime),
          },
        });
        this.preserveInactiveTimeScale();
      });

    this.subscriptions.add(this.optionsSubscription);

    this.mouseEvents = new ChartMouseEvents({
      lwcChart: this.lwcChart,
      container: this.container,
    });

    this.mouseEvents.subscribe('wheel', this.onWheel);
    this.mouseEvents.subscribe('pointerDown', this.onPointerDown);
    this.mouseEvents.subscribe('pointerMove', this.onPointerMove);
    this.mouseEvents.subscribe('pointerUp', this.onPointerUp);
    this.mouseEvents.subscribe('pointerCancel', this.onPointerUp);

    this.DOM = new DOMModel({
      modalRenderer,
    });

    this.paneManager = new PaneManager({
      eventManager: this.eventManager,
      panesSnapshot,
      lwcChart: this.lwcChart,
      dataSource,
      DOM: this.DOM,
      ohlcConfig,
      subscribeChartEvent: this.subscribeChartEvent,
      chartContainer: this.container,
      tooltipConfig,
      modalRenderer,
      hotkeys: params.hotkeys,
    });

    this.mainSeries = this.paneManager.getMainPane().getMainSerie();

    const { indicatorSnapshots, compareSnapshots } = splitIndicatorSnapshots(panesSnapshot);

    this.indicatorManager = new IndicatorManager({
      lwcChart: this.lwcChart,
      eventManager,
      dataSource: this.dataSource,
      paneManager: this.paneManager,
      initialIndicators: indicatorSnapshots,
      DOM: this.DOM,
      chartOptions: lwcChartConfig.chartOptions,
    });

    this.compareManager = new CompareManager({
      chart: this.lwcChart,
      eventManager,
      dataSource: this.dataSource,
      paneManager: this.paneManager,
      initialIndicators: compareSnapshots,
      indicatorManager: this.indicatorManager,
    });

    this.paneManager.start({
      compareEntities$: this.compareManager.entities(),
      indicatorEntities$: this.indicatorManager.entities(),
    });

    this.paneManager.setVisibleLogicalRange(this.lwcChart.timeScale().getVisibleLogicalRange());
    this.paneManager.invalidate();

    this.setupDataSourceSubs();
    this.setupHistoricalDataLoading();
  }

  public getPriceScaleWidth(direction: Direction): number {
    try {
      const priceScale = this.lwcChart.priceScale(direction);

      return priceScale ? priceScale.width() : 0;
    } catch {
      return 0;
    }
  }

  public getDrawingsCollectionManager = (): DrawingsManagerCollection => {
    return this.paneManager.getDrawingsCollectionManager();
  };

  public getIndicatorManager = (): IndicatorManager => {
    return this.indicatorManager;
  };

  private onWheel = () => {
    if (!this.active) return;
    this.eventManager.resetInterval({
      history: false,
    });
  };

  private onPointerDown = (event: PointerEvent) => {
    if (!this.active) return;
    if (event.composedPath().includes(this.lwcChart.chartElement())) {
      this.container.focus({ preventScroll: true });
    }

    this.isPointerDown = true;
    this.didResetOnDrag = false;
  };

  private onPointerMove = () => {
    if (!this.active) return;
    if (!this.isPointerDown) return;
    if (this.didResetOnDrag) return;

    this.didResetOnDrag = true;

    this.eventManager.resetInterval({
      history: false,
    });
  };

  private onPointerUp = () => {
    this.isPointerDown = false;
  };

  public getDom(): DOMModel {
    return this.DOM;
  }

  public getMainSeries(): Observable<SeriesStrategies | null> {
    return this.mainSeries.asObservable();
  }

  public getCompareManager(): CompareManager {
    return this.compareManager;
  }

  public updateTheme(theme: ThemeKey, mode: ThemeMode) {
    this.chartConfig = {
      ...this.chartConfig,
      theme,
      mode,
    };

    this.lwcChart.applyOptions(getOptions(this.chartConfig));
    this.preserveInactiveTimeScale();

    this.paneManager.invalidate();
  }

  public setActive(active: boolean): void {
    if (this.active === active) return;
    this.active = active;
    this.isPointerDown = false;
    const timeScale = this.lwcChart.timeScale();
    if (!active) {
      const options = timeScale.options();
      this.savedViewport = {
        logicalRange: timeScale.getVisibleLogicalRange(),
        timeRange: timeScale.getVisibleRange(),
        oldestTimes: this.activeSymbolIds.map((symbolId) => this.dataSource.getOldestTime(symbolId)),
        shiftVisibleRangeOnNewBar: options.shiftVisibleRangeOnNewBar,
        allowShiftVisibleRangeOnWhitespaceReplacement: options.allowShiftVisibleRangeOnWhitespaceReplacement,
      };
      this.preserveInactiveTimeScale();
      return;
    }
    const saved = this.savedViewport;
    this.savedViewport = null;
    if (saved) {
      timeScale.applyOptions({
        shiftVisibleRangeOnNewBar: saved.shiftVisibleRangeOnNewBar,
        allowShiftVisibleRangeOnWhitespaceReplacement: saved.allowShiftVisibleRangeOnWhitespaceReplacement,
      });
      const historyChanged = this.activeSymbolIds.some(
        (symbolId, index) => this.dataSource.getOldestTime(symbolId) !== saved.oldestTimes[index],
      );
      if (historyChanged && saved.timeRange) {
        timeScale.setVisibleRange(saved.timeRange);
      } else if (saved.logicalRange) {
        timeScale.setVisibleLogicalRange(saved.logicalRange);
      }
    }
  }

  private preserveInactiveTimeScale(): void {
    if (this.active) return;
    this.lwcChart.timeScale().applyOptions({
      shiftVisibleRangeOnNewBar: false,
      allowShiftVisibleRangeOnWhitespaceReplacement: false,
    });
  }

  public destroy(): void {
    this.subscriptions.unsubscribe();
    this.mouseEvents.destroy();
    this.compareManager.destroy();
    this.paneManager.destroy();
    this.lwcChart.remove();
  }

  public subscribeChartEvent: ChartMouseEvents['subscribe'] = (event, callback) =>
    this.mouseEvents.subscribe(event, callback);

  public unsubscribeChartEvent: ChartMouseEvents['unsubscribe'] = (event, callback) => {
    this.mouseEvents.unsubscribe(event, callback);
  };

  // todo: add/move to undo/redo model(eventManager)
  public scrollTimeScale = (direction: Direction) => {
    if (!this.active) return;
    this.eventManager.resetInterval({
      history: false,
    });

    const diff = direction === Direction.Left ? -2 : 2;
    const currentPosition = this.lwcChart.timeScale().scrollPosition();

    this.lwcChart.timeScale().scrollToPosition(currentPosition + diff, false);
  };

  // todo: add/move to undo/redo model(eventManager)
  public zoomTimeScale = (resize: Resize) => {
    if (!this.active) return;
    this.eventManager.resetInterval({
      history: false,
    });

    const diff = resize === Resize.Shrink ? -1 : 1;

    const currentRange = this.lwcChart.timeScale().getVisibleRange();

    if (!currentRange) return;

    const { from, to } = currentRange as IRange<number>;

    if (!from || !to) return;

    const next: IRange<Time> = {
      from: (from + (to - from) * 0.1 * diff) as Time,
      to: to as Time,
    };

    this.lwcChart.timeScale().setVisibleRange(next);
  };

  // todo: add to undo/redo model(eventManager)
  public resetZoom = () => {
    if (!this.active) return;
    this.eventManager.resetInterval({
      history: false,
    });

    this.lwcChart.timeScale().resetTimeScale();

    this.paneManager.resetPriceScalesAutoScale();
  };

  public getRealtimeApi() {
    return {
      getTimeframe: () => this.eventManager.getTimeframe(),
      getSymbols: () => this.activeSymbolIds,
      update: (symbolId: string, candle: Candle) => {
        this.dataSource.updateRealtime(symbolId, candle);
      },
    };
  }

  public getSnapshot(): ChartSnapshot {
    const { seriesSelected, timeframe, dateFormat, timeFormat, interval, symbolInfo } =
      this.eventManager.exportChartSettings();

    return {
      panes: this.paneManager.getSnapshot(),
      chartSeriesType: seriesSelected,
      timeframe,
      dateFormat,
      timeFormat,
      interval,
      ...symbolInfo,
    };
  }

  public async copyImage(): Promise<void> {
    const canvas = this.lwcChart.takeScreenshot(true, false);
    const chartElement = this.lwcChart.chartElement();

    chartElement.querySelectorAll<HTMLElement>(`.${CHART_PANE_LEGEND_CONTAINER}`).forEach((legend) => {
      if (legend.hidden || window.getComputedStyle(legend).display === 'none') {
        return;
      }

      drawTextLayer(canvas, legend, chartElement);
    });

    const blob = await canvasToBlob(canvas);

    await navigator.clipboard.write([
      new ClipboardItem({
        'image/png': blob,
      }),
    ]);
  }

  private scheduleHistoryBatch(): void {
    if (!this.active || this.subscriptions.closed || this.historyBatchRunning || this.activeSymbolIds.length === 0) {
      return;
    }

    this.historyBatchRunning = true;

    requestAnimationFrame(() => {
      if (!this.active || this.subscriptions.closed) {
        this.historyBatchRunning = false;

        return;
      }

      const symbolIds = this.activeSymbolIds.slice();
      const timeframe = this.eventManager.getTimeframe();
      const oldestTimes = symbolIds.map((symbolId) => this.dataSource.getOldestTime(symbolId));

      Promise.all(symbolIds.map((symbolId) => this.dataSource.loadMoreHistory(symbolId)))
        .catch((error) => console.error('[Chart] History batch failed:', error))
        .finally(() => this.finishHistoryBatch(symbolIds, oldestTimes, timeframe));
    });
  }

  private finishHistoryBatch(
    symbolIds: string[],
    oldestTimes: (number | null)[],
    timeframe: ReturnType<EventManager['getTimeframe']>,
  ): void {
    this.historyBatchRunning = false;

    if (!this.active || this.subscriptions.closed) {
      return;
    }

    const contextChanged =
      timeframe !== this.eventManager.getTimeframe() || isUniqueSymbolId(symbolIds, this.activeSymbolIds);

    const hasProgress = this.hasHistoryProgress(symbolIds, oldestTimes);

    if (!contextChanged && !hasProgress) {
      return;
    }

    const range = this.lwcChart.timeScale().getVisibleLogicalRange();

    if (range && range.from < HISTORY_LOAD_THRESHOLD) {
      this.scheduleHistoryBatch();
    }
  }

  private hasHistoryProgress(symbolIds: string[], oldestTimes: (number | null)[]): boolean {
    return symbolIds.some((symbolId, index) => {
      if (!this.activeSymbolIds.includes(symbolId)) {
        return false;
      }

      const previousOldestTime = oldestTimes[index];
      const currentOldestTime = this.dataSource.getOldestTime(symbolId);

      return currentOldestTime !== null && (previousOldestTime === null || currentOldestTime < previousOldestTime);
    });
  }

  private async warmupSymbols(symbolIds: string[]): Promise<void> {
    const range = this.lwcChart.timeScale().getVisibleRange() as IRange<number> | null;

    if (range === null) {
      return;
    }

    await Promise.all(symbolIds.map((symbolId) => this.dataSource.loadTill(symbolId, range.from)));
  }

  private async loadIntervalRange(interval: Intervals, symbolIds: string[]): Promise<IRange<Time> | null> {
    if (interval === Intervals.All) {
      await Promise.all(symbolIds.map((symbolId) => this.dataSource.loadAllHistory(symbolId)));

      const firstTimes = symbolIds
        .map((symbolId) => this.dataSource.getOldestTime(symbolId))
        .filter((time): time is number => time !== null);

      const lastTimes = symbolIds
        .map((symbolId) => this.dataSource.getLastCandle(symbolId)?.time)
        .filter((time): time is number => time !== undefined);

      if (firstTimes.length === 0 || lastTimes.length === 0) {
        return null;
      }

      return {
        from: Math.min(...firstTimes) as Time,
        to: Math.max(...lastTimes) as Time,
      };
    }

    const { from, to } = getIntervalRange(interval);

    await Promise.all(symbolIds.map((symbolId) => this.dataSource.loadTill(symbolId, from)));

    const hasData = symbolIds.some((symbolId) => this.dataSource.getOldestTime(symbolId) !== null);

    if (!hasData) {
      return null;
    }

    return {
      from: from as Time,
      to: to as Time,
    };
  }

  private setupDataSourceSubs(): void {
    let symbolsRegistered = false;

    const symbols$ = combineLatest([this.eventManager.symbolId(), this.compareManager.itemsObs()]).pipe(
      map(([mainSymbolId, items]) => {
        const symbolIds = Array.from(
          new Set([mainSymbolId, ...items.map(({ symbolId }) => symbolId)].filter((symbolId) => symbolId !== '')),
        );

        return {
          mainSymbolId,
          symbolIds,
        };
      }),
      distinctUntilChanged(
        (previous, next) =>
          previous.mainSymbolId === next.mainSymbolId && !isUniqueSymbolId(previous.symbolIds, next.symbolIds),
      ),
    );

    this.subscriptions.add(
      combineLatest([this.eventManager.getInterval().pipe(distinctUntilChanged()), symbols$])
        .pipe(
          switchMap(([interval, { symbolIds }]) => {
            const previousSymbolIds = this.activeSymbolIds;
            const previousSymbolIdsSet = new Set(previousSymbolIds);
            const addedSymbolIds = symbolIds.filter((symbolId) => !previousSymbolIdsSet.has(symbolId));

            this.activeSymbolIds = symbolIds;

            if (!symbolsRegistered || isUniqueSymbolId(previousSymbolIds, symbolIds)) {
              symbolsRegistered = true;
              this.dataSource.setSymbols(symbolIds);
            }

            if (symbolIds.length === 0) {
              return EMPTY;
            }

            if (interval === null) {
              if (addedSymbolIds.length === 0) {
                return EMPTY;
              }

              return defer(() => this.warmupSymbols(addedSymbolIds)).pipe(
                ignoreElements(),
                catchError((error) => {
                  console.error('[Chart] Ошибка при прогреве символов:', error);

                  return EMPTY;
                }),
              );
            }

            return defer(() => this.loadIntervalRange(interval, symbolIds)).pipe(
              filter((range): range is IRange<Time> => range !== null),
              tap((range) => {
                if (this.active) this.lwcChart.timeScale().setVisibleRange(range);
              }),
              catchError((error) => {
                console.error('[Chart] Ошибка при применении интервала:', error);

                return EMPTY;
              }),
            );
          }),
        )
        .subscribe(),
    );
  }

  private setupHistoricalDataLoading(): void {
    // todo (не)вызвать loadMoreHistory после проверки на необходимость дозагрузки после смены таймфрейма
    this.mouseEvents.subscribe('visibleLogicalRangeChange', (logicalRange: LogicalRange | null) => {
      this.paneManager.setVisibleLogicalRange(logicalRange);

      if (!logicalRange) return;

      const needsMoreData = logicalRange.from < HISTORY_LOAD_THRESHOLD;

      if (!needsMoreData) return;

      this.scheduleHistoryBatch();
    });
  }
}

function isUniqueSymbolId(previous: string[], next: string[]): boolean {
  if (previous.length !== next.length) {
    return true;
  }

  const nextSet = new Set(next);

  return previous.some((symbolId) => !nextSet.has(symbolId));
}

function getIntervalRange(interval: Intervals): {
  from: number;
  to: number;
} {
  const { value, unit } = intervalsToDayjs[interval] as DayjsOffset;

  const from = Math.floor(dayjs().subtract(value, unit).valueOf() / 1000);
  const to = Math.floor(dayjs().valueOf() / 1000);

  return {
    from,
    to,
  };
}

function getOptions(config: ChartConfig): DeepPartial<ChartOptions> {
  const timeFormat = config.timeFormat ?? Defaults.timeFormat;
  const showTime = config.showTime ?? Defaults.showTime;

  const use12HourFormat = timeFormat === '12h';
  const timeFormatString = use12HourFormat ? 'h:mm A' : 'HH:mm';

  const { colors } = getThemeStore();

  const localization: LocalizationOptionsBase = {
    locale: getLocale(),
    priceFormatter: (priceValue: BarPrice) => {
      return formatCompactNumber(priceValue);
    },
  };

  return {
    width: config.container.clientWidth,
    height: config.container.clientHeight,
    autoSize: true,
    defaultVisiblePriceScaleId: Direction.Right,
    layout: {
      background: {
        color: colors.chartBackground,
      },
      textColor: colors.chartTextPrimary,
      panes: {
        separatorColor: colors.chartPaneSeparator,
        separatorHoverColor: colors.chartPaneSeparator,
        enableResize: true,
      },
    },
    grid: {
      vertLines: {
        color: colors.chartGridLine,
      },
      horzLines: {
        color: colors.chartGridLine,
      },
    },
    crosshair: {
      mode: CrosshairMode.Normal,
      vertLine: {
        color: colors.chartCrosshairLine,
        labelBackgroundColor: colors.chartCrosshairLabel,
        style: 0,
      },
      horzLine: {
        color: colors.chartCrosshairLine,
        labelBackgroundColor: colors.chartCrosshairLabel,
        style: 2,
      },
    },
    timeScale: {
      timeVisible: showTime,
      secondsVisible: false,
      tickMarkFormatter: createTickMarkFormatter(timeFormatString),
      borderVisible: false,
      allowBoldLabels: false,
      rightOffset: 10,
      shiftVisibleRangeOnNewBar: true,
      allowShiftVisibleRangeOnWhitespaceReplacement: true,
    },
    rightPriceScale: {
      minimumWidth: 60,
      borderVisible: false,
    },
    leftPriceScale: {
      minimumWidth: 60,
      borderVisible: false,
    },
    localization,
  };
}

















import {
  CHART_DRAWING_TOOLBAR_CONTAINER,
  CHART_MODAL_CONTAINER_CLASSNAME,
  CHART_PANE_EMPTY_STATE_CONTAINER,
  CHART_PANE_LEGEND_CONTAINER,
  CHART_PANE_OVERLAY_CONTAINER,
  CHART_ROOT_CLASSNAME,
} from '@src/constants';

import { ContainerManager } from '../ContainerManager';

jest.mock('@src/constants', () => ({
  CHART_DRAWING_TOOLBAR_CONTAINER: 'chart-drawing-toolbar-container',
  CHART_MODAL_CONTAINER_CLASSNAME: 'chart-modal-container',
  CHART_PANE_EMPTY_STATE_CONTAINER: 'chart-pane-empty-state-container',
  CHART_PANE_LEGEND_CONTAINER: 'chart-pane-legend-container',
  CHART_PANE_OVERLAY_CONTAINER: 'chart-pane-overlay-container',
  CHART_ROOT_CLASSNAME: 'chart-root',
  CHART_SCROLLABLE_CLASSNAME: 'chart-scrollable',
}));

describe('ContainerManager', () => {
  let parentContainer: HTMLDivElement;

  beforeEach(() => {
    document.querySelectorAll('link[href*="fonts.googleapis.com"]').forEach((link) => link.remove());

    parentContainer = document.createElement('div');
    document.body.appendChild(parentContainer);
  });

  afterEach(() => {
    parentContainer.remove();
  });

  describe('createContainers', () => {
    it('должен создавать основные контейнеры графика с корректной структурой', () => {
      const {
        headerContainer,
        footerContainer,
        chartContainer,
        chartAreaContainer,
        toolBarContainer,
        modalContainer,
        controlBarContainer,
        drawingToolbarContainer,
      } = ContainerManager.createContainers({
        parentContainer,
        showBottomPanel: true,
        showMenuButton: true,
      });

      expect(parentContainer.classList.contains(CHART_ROOT_CLASSNAME)).toBe(true);
      expect(parentContainer.children[0]).toBe(headerContainer);
      expect(parentContainer.children[1]).toBe(chartContainer);
      expect(parentContainer.children[2]).toBe(footerContainer);

      expect(chartContainer.contains(toolBarContainer)).toBe(true);
      expect(chartContainer.contains(chartAreaContainer)).toBe(true);
      expect(chartContainer.contains(modalContainer)).toBe(true);

      expect(chartAreaContainer.contains(controlBarContainer)).toBe(true);
      expect(chartAreaContainer.contains(drawingToolbarContainer)).toBe(true);

      expect(drawingToolbarContainer.classList.contains(CHART_DRAWING_TOOLBAR_CONTAINER)).toBe(true);
      expect(modalContainer.classList.contains(CHART_MODAL_CONTAINER_CLASSNAME)).toBe(true);
      expect(modalContainer.hidden).toBe(true);
    });

    it('должен создавать сетку с нижней панелью', () => {
      ContainerManager.createContainers({
        parentContainer,
        showBottomPanel: true,
        showMenuButton: true,
      });

      expect(parentContainer.style.gridTemplateRows).toBe('36px minmax(0, 1fr) 32px');
    });

    it('должен создавать сетку без нижней панели', () => {
      const { footerContainer } = ContainerManager.createContainers({
        parentContainer,
        showBottomPanel: false,
        showMenuButton: true,
      });

      expect(parentContainer.style.gridTemplateRows).toBe('36px minmax(0, 1fr)');
      expect(parentContainer.contains(footerContainer)).toBe(false);
    });

    it('должен отображать панель инструментов при включённой кнопке меню', () => {
      const { chartContainer, toolBarContainer } = ContainerManager.createContainers({
        parentContainer,
        showMenuButton: true,
      });

      expect(chartContainer.contains(toolBarContainer)).toBe(true);
      expect(chartContainer.style.gridTemplateColumns).toBe('42px minmax(0, 1fr)');
    });

    it('должен скрывать панель инструментов при выключенной кнопке меню', () => {
      const { chartContainer, toolBarContainer } = ContainerManager.createContainers({
        parentContainer,
        showMenuButton: false,
      });

      expect(chartContainer.contains(toolBarContainer)).toBe(false);
      expect(chartContainer.style.gridTemplateColumns).toBe('minmax(0, 1fr)');
    });

    it('должен переключать видимость панели инструментов', () => {
      const { chartContainer, toolBarContainer, toggleToolbar } = ContainerManager.createContainers({
        parentContainer,
        showMenuButton: true,
      });

      expect(toggleToolbar()).toBe(false);
      expect(chartContainer.contains(toolBarContainer)).toBe(false);
      expect(chartContainer.style.gridTemplateColumns).toBe('minmax(0, 1fr)');

      expect(toggleToolbar()).toBe(true);
      expect(chartContainer.contains(toolBarContainer)).toBe(true);
      expect(chartContainer.style.gridTemplateColumns).toBe('42px minmax(0, 1fr)');
    });

    it('должен удалять старое содержимое перед созданием контейнеров', () => {
      const oldElement = document.createElement('div');

      parentContainer.appendChild(oldElement);

      ContainerManager.createContainers({
        parentContainer,
        showMenuButton: true,
      });

      expect(parentContainer.contains(oldElement)).toBe(false);
    });

    it('должен добавлять шрифт только один раз', () => {
      ContainerManager.createContainers({
        parentContainer,
        showMenuButton: true,
      });

      ContainerManager.createContainers({
        parentContainer,
        showMenuButton: true,
      });

      expect(document.querySelectorAll('link[href*="fonts.googleapis.com"]')).toHaveLength(1);
    });
  });

  describe('createPaneContainers', () => {
    it('должен создавать контейнеры pane с корректными настройками', () => {
      const { legendContainer, paneOverlayContainer, paneEmptyStateContainer } =
        ContainerManager.createPaneContainers();

      expect(legendContainer.classList.contains(CHART_PANE_LEGEND_CONTAINER)).toBe(true);
      expect(legendContainer.style.position).toBe('absolute');
      expect(legendContainer.style.pointerEvents).toBe('none');

      expect(paneOverlayContainer.classList.contains(CHART_PANE_OVERLAY_CONTAINER)).toBe(true);
      expect(paneOverlayContainer.style.position).toBe('absolute');
      expect(paneOverlayContainer.style.inset).toBe('0');
      expect(paneOverlayContainer.style.pointerEvents).toBe('none');

      expect(paneEmptyStateContainer.classList.contains(CHART_PANE_EMPTY_STATE_CONTAINER)).toBe(true);
      expect(paneEmptyStateContainer.hidden).toBe(true);
    });

    it('должен создавать отдельные контейнеры для каждого pane', () => {
      const first = ContainerManager.createPaneContainers();
      const second = ContainerManager.createPaneContainers();

      expect(first.legendContainer).not.toBe(second.legendContainer);
      expect(first.paneOverlayContainer).not.toBe(second.paneOverlayContainer);
      expect(first.paneEmptyStateContainer).not.toBe(second.paneEmptyStateContainer);
    });
  });

  describe('clearContainers', () => {
    it('должен очищать содержимое контейнера', () => {
      parentContainer.innerHTML = '<div>content</div>';

      ContainerManager.clearContainers(parentContainer);

      expect(parentContainer.innerHTML).toBe('');
    });
  });
});

















import {
  CHART_DRAWING_TOOLBAR_CONTAINER,
  CHART_MODAL_CONTAINER_CLASSNAME,
  CHART_PANE_EMPTY_STATE_CONTAINER,
  CHART_PANE_LEGEND_CONTAINER,
  CHART_PANE_OVERLAY_CONTAINER,
  CHART_ROOT_CLASSNAME,
  CHART_SCROLLABLE_CLASSNAME,
} from '@src/constants';

interface CreateContainersOptions {
  parentContainer: HTMLElement;
  showBottomPanel?: boolean;
  showMenuButton?: boolean;
}

export enum ZIndex {
  Chart = '0',
  Base = '1',
  Legend = '2',
  Floating = '3',
  Modal = '1000',
}

const ContainerLayoutConfig = {
  headerHeight: 36,
  footerHeight: 32,
  toolbarWidth: 42,
  verticalGap: 8,
};

/**
 * Утилита для создания DOM контейнеров
 */
export class ContainerManager {
  private static injectFont(): void {
    const existingLink = document.querySelector('link[href*="fonts.googleapis.com"]');

    if (existingLink) {
      return;
    }

    const link = document.createElement('link');
    link.rel = 'stylesheet';
    link.href = 'https://fonts.googleapis.com/css2?family=Inter:opsz,wght@14..32,100..900&display=swap';
    document.head.appendChild(link);
  }

  /**
   * Создание контейнеров для графика и UI компонентов
   */
  static createContainers({ parentContainer, showBottomPanel, showMenuButton }: CreateContainersOptions) {
    this.injectFont();

    const { headerHeight, footerHeight, toolbarWidth, verticalGap } = ContainerLayoutConfig;

    parentContainer.innerHTML = '';
    parentContainer.classList.add(CHART_ROOT_CLASSNAME);

    Object.assign(parentContainer.style, {
      height: '100%',
      width: '100%',
      padding: 'var(--space-1000)',
      backgroundColor: 'var(--neutral-0)',
      borderRadius: 'var(--space-0500)',
      display: 'grid',
      rowGap: `${verticalGap}px`,
      gridTemplateRows: showBottomPanel
        ? `${headerHeight}px minmax(0, 1fr) ${footerHeight}px`
        : `${headerHeight}px minmax(0, 1fr)`,
    });

    const headerContainer = document.createElement('div');
    headerContainer.classList.add(CHART_SCROLLABLE_CLASSNAME);

    Object.assign(headerContainer.style, {
      width: '100%',
      height: `${headerHeight}px`,
      overflow: 'auto hidden',
    });

    const footerContainer = document.createElement('div');

    Object.assign(footerContainer.style, {
      width: '100%',
      height: `${footerHeight}px`,
    });

    const chartViewContainer = document.createElement('div');

    Object.assign(chartViewContainer.style, {
      position: 'relative',
      display: 'grid',
      minWidth: '0',
      minHeight: '0',
    });

    const chartContainer = document.createElement('div');

    Object.assign(chartContainer.style, {
      position: 'relative',
      gridArea: '1 / 1',
      height: '100%',
      width: '100%',
      minWidth: '0',
      minHeight: '0',
      display: 'grid',
      columnGap: 'var(--space-0500)',
      gridTemplateColumns: 'minmax(0, 1fr)',
    });

    const chartAreaContainer = document.createElement('div');
    chartAreaContainer.tabIndex = -1;

    Object.assign(chartAreaContainer.style, {
      position: 'relative',
      height: '100%',
      minHeight: '0',
      minWidth: '0',
      outline: 'none',
      cursor: 'crosshair',
    });

    const seasonalityContainer = document.createElement('div');
    seasonalityContainer.tabIndex = -1;
    seasonalityContainer.inert = true;

    Object.assign(seasonalityContainer.style, {
      position: 'relative',
      gridArea: '1 / 1',
      minWidth: '0',
      minHeight: '0',
      visibility: 'hidden',
      pointerEvents: 'none',
      zIndex: ZIndex.Base,
      overflow: 'hidden',
      display: 'grid',
      gridTemplateRows: 'auto minmax(0, 1fr)',
      rowGap: 'var(--space-0500)',
      outline: 'none',
      userSelect: 'none',
    });

    const seasonalityControlsContainer = document.createElement('div');

    Object.assign(seasonalityControlsContainer.style, {
      minWidth: '0',
    });

    const seasonalityPlotContainer = document.createElement('div');

    Object.assign(seasonalityPlotContainer.style, {
      position: 'relative',
      minWidth: '0',
      minHeight: '0',
    });

    const toolBarContainer = document.createElement('div');

    Object.assign(toolBarContainer.style, {
      height: '100%',
      minHeight: '0',
      overflow: 'hidden',
    });

    const controlBarContainer = document.createElement('div');

    Object.assign(controlBarContainer.style, {
      position: 'absolute',
      left: '50%',
      transform: 'translateX(-50%)',
      bottom: 'var(--space-2000)',
      zIndex: ZIndex.Floating,
    });

    const drawingToolbarContainer = document.createElement('div');
    drawingToolbarContainer.classList.add(CHART_DRAWING_TOOLBAR_CONTAINER);

    Object.assign(drawingToolbarContainer.style, {
      position: 'absolute',
      inset: '0',
      zIndex: ZIndex.Floating,
      pointerEvents: 'none',
      overflow: 'hidden',
    });

    const modalContainer = document.createElement('div');
    modalContainer.classList.add(CHART_MODAL_CONTAINER_CLASSNAME);
    modalContainer.hidden = true;

    Object.assign(modalContainer.style, {
      position: 'absolute',
      inset: '0',
      zIndex: ZIndex.Modal,
    });

    seasonalityContainer.append(seasonalityControlsContainer, seasonalityPlotContainer);
    chartAreaContainer.append(controlBarContainer, drawingToolbarContainer);
    chartContainer.append(chartAreaContainer, modalContainer);
    chartViewContainer.append(chartContainer, seasonalityContainer);
    parentContainer.append(headerContainer, chartViewContainer);

    if (showBottomPanel) {
      parentContainer.append(footerContainer);
    }

    const toggleToolbar = () => {
      if (toolBarContainer.isConnected) {
        toolBarContainer.remove();

        Object.assign(chartContainer.style, {
          gridTemplateColumns: 'minmax(0, 1fr)',
        });

        return false;
      }

      chartContainer.insertBefore(toolBarContainer, chartAreaContainer);

      Object.assign(chartContainer.style, {
        gridTemplateColumns: `${toolbarWidth}px minmax(0, 1fr)`,
      });

      return true;
    };

    if (showMenuButton) {
      toggleToolbar();
    }

    return {
      headerContainer,
      footerContainer,
      chartContainer,
      seasonalityContainer,
      seasonalityControlsContainer,
      seasonalityPlotContainer,
      chartAreaContainer,
      toolBarContainer,
      modalContainer,
      controlBarContainer,
      drawingToolbarContainer,
      toggleToolbar,
    };
  }

  /**
   * Очистка контейнеров
   */
  static clearContainers(parentContainer: HTMLElement): void {
    parentContainer.innerHTML = '';
  }

  static createPaneContainers() {
    const legendContainer = document.createElement('div');
    legendContainer.classList.add(CHART_PANE_LEGEND_CONTAINER);

    Object.assign(legendContainer.style, {
      position: 'absolute',
      top: '0',
      left: '0',
      zIndex: ZIndex.Legend,
      pointerEvents: 'none',
    });

    const paneOverlayContainer = document.createElement('div');
    paneOverlayContainer.classList.add(CHART_PANE_OVERLAY_CONTAINER);

    Object.assign(paneOverlayContainer.style, {
      position: 'absolute',
      inset: '0',
      zIndex: ZIndex.Base,
      pointerEvents: 'none',
    });

    const paneEmptyStateContainer = document.createElement('div');
    paneEmptyStateContainer.classList.add(CHART_PANE_EMPTY_STATE_CONTAINER);
    paneEmptyStateContainer.hidden = true;

    return {
      legendContainer,
      paneOverlayContainer,
      paneEmptyStateContainer,
    };
  }
}















import { IMoexChart, MoexChart } from '@core/MoexChart';

import type { ReactElement } from 'react';

describe('MoexChart', () => {
  it('должен очищать основной инструмент через EventManager', () => {
    const clearSymbol = jest.fn();
    const chart = Object.create(MoexChart.prototype) as MoexChart;

    (chart as unknown as { eventManager: { clearSymbol: () => void } }).eventManager = {
      clearSymbol,
    };

    chart.clearSymbol();

    expect(clearSymbol).toHaveBeenCalledTimes(1);
  });

  it('должен устанавливать основной инструмент через EventManager', () => {
    const setSymbol = jest.fn();
    const chart = Object.create(MoexChart.prototype) as MoexChart;

    (chart as unknown as { eventManager: { setSymbol: typeof setSymbol } }).eventManager = {
      setSymbol,
    };

    chart.setSymbol({
      symbolId: 'SBER',
      symbol: 'SBER',
      symbolName: 'Sberbank',
    });

    expect(setSymbol).toHaveBeenCalledWith({
      symbolId: 'SBER',
      symbol: 'SBER',
      symbolName: 'Sberbank',
    });
  });

  function renderHeader(showSnapshotButton?: boolean) {
    const copyImage = jest.fn().mockResolvedValue(undefined);
    const headerRenderer = { renderComponent: jest.fn() };
    const drawingToolbarRenderer = { renderComponent: jest.fn() };

    const drawingsCollectionManager = {
      selectedDrawing: jest.fn(),
      updateSelectedDrawingSettings: jest.fn(),
      toggleSelectedDrawingLock: jest.fn(),
      openSelectedDrawingSettings: jest.fn(),
      deleteSelectedDrawing: jest.fn(),
    };

    const chart = Object.create(MoexChart.prototype) as MoexChart;

    const internals = chart as unknown as {
      chart: {
        copyImage: () => Promise<void>;
        getDrawingsCollectionManager: () => typeof drawingsCollectionManager;
      };
      drawingToolbarRenderer: typeof drawingToolbarRenderer;
      headerRenderer: typeof headerRenderer;
      toolbarRenderer: undefined;
      controlBarRenderer: undefined;
      footerRenderer: undefined;
      eventManager: {
        getTimeframeObs: jest.Mock;
        setTimeframe: jest.Mock;
        getSelectedSeries: jest.Mock;
        setSeriesSelected: jest.Mock;
      };
      modalRenderer: object;
      fullscreen: object;
      renderAttachments: (config: IMoexChart, toggleToolbar: () => boolean) => void;
    };

    internals.chart = {
      copyImage,
      getDrawingsCollectionManager: () => drawingsCollectionManager,
    };

    internals.drawingToolbarRenderer = drawingToolbarRenderer;
    internals.headerRenderer = headerRenderer;
    internals.toolbarRenderer = undefined;
    internals.controlBarRenderer = undefined;
    internals.footerRenderer = undefined;
    internals.modalRenderer = {};
    internals.fullscreen = {};

    internals.eventManager = {
      getTimeframeObs: jest.fn(),
      setTimeframe: jest.fn(),
      getSelectedSeries: jest.fn(),
      setSeriesSelected: jest.fn(),
    };

    const config = {
      chartCollectionPreset: {
        supportedTimeframes: [],
        supportedChartSeriesTypes: [],
        showSettingsButton: false,
        showMenuButton: false,
        showFullscreenButton: false,
        undoRedoEnabled: false,
        showCompareButton: false,
        showSnapshotButton,
        openCompareModal: undefined,
        openSymbolSearchModal: undefined,
        theme: 'tr',
      },
    } as unknown as IMoexChart;

    internals.renderAttachments(
      config,
      jest.fn(() => false),
    );

    const header = headerRenderer.renderComponent.mock.calls[0][0] as ReactElement<{
      copyImage?: () => Promise<void>;
    }>;

    return { header, copyImage };
  }

  it('должен передавать copyImage в Header, если снимок включён', async () => {
    const { header, copyImage } = renderHeader(true);

    expect(header.props.copyImage).toBeDefined();

    await header.props.copyImage!();

    expect(copyImage).toHaveBeenCalledTimes(1);
  });

  it('не должен передавать copyImage в Header, если настройка снимка не задана', () => {
    const { header, copyImage } = renderHeader();

    expect(header.props.copyImage).toBeUndefined();
    expect(copyImage).not.toHaveBeenCalled();
  });

  it('не должен передавать copyImage в Header, если снимок отключён', () => {
    const { header, copyImage } = renderHeader(false);

    expect(header.props.copyImage).toBeUndefined();
    expect(copyImage).not.toHaveBeenCalled();
  });
});

















import { combineLatest, Subscription } from 'rxjs';

import { ControlBar } from '@components/ControlBar';
import { Footer } from '@components/Footer';
import { Header } from '@components/Header';

import { DataSource, DataSourceParams } from '@core/DataSource';
import { Hotkeys, Keys } from '@core/Hotkeys';
import { ModalRenderer } from '@core/ModalRenderer';

import { FloatingDrawingToolbar } from '@src/components/FloatingToolbar';
import { SeasonalityControls } from '@src/components/SeasonalityControls';
import { SettingsModal } from '@src/components/SettingsModal';
import Toolbar from '@src/components/Toolbar';

import { IndicatorsIds } from '@src/constants';
import { CompareManager } from '@src/core/CompareManager';
import { FullscreenController } from '@src/core/Fullscreen';

import { SeasonalityManager } from '@src/core/SeasonalityManager';
import { configureThemeStore } from '@src/theme/store';
import { ThemeKey, ThemeMode } from '@src/theme/types';
import { Locale, setLocale, t } from '@src/translations';

import {
  Candle,
  ChartSeriesType,
  ChartTypeOptions,
  ChartViewType,
  OHLCConfig,
  SeasonalityRange,
  SymbolInfoInput,
  TooltipConfig,
} from '@src/types';
import { ISerializable, MoexChartSnapshot, MoexChartSnapshotInput } from '@src/types/snapshot';
import { Timeframes } from '@src/types/timeframes';

import { setPricePrecision } from '@src/utils';

import { Chart } from './Chart';
import { ChartSettings, ChartSettingsSource } from './ChartSettings';
import { ContainerManager } from './ContainerManager';
import { EventManager } from './EventManager';
import { ReactRenderer } from './ReactRenderer';
import { TimeScaleHoverController } from './TimescaleHoverController';
import { UIRenderer } from './UIRenderer';

import 'exchange-elements/dist/fonts/inter/font.css';
import 'exchange-elements/dist/style.css';
import 'exchange-elements/dist/tokens/moex.css';
import '../styles/global.scss';

// todo: forbid @lib in /src
export interface ChartCollectionPreset {
  undoRedoEnabled?: boolean;
  showMenuButton?: boolean;
  showBottomPanel?: boolean;
  showControlBar?: boolean;
  showFullscreenButton?: boolean;
  showSettingsButton?: boolean;
  showCompareButton?: boolean;
  showSymbolSearchButton?: boolean;
  showSnapshotButton?: boolean;
  showSeasonalityButton?: boolean;

  /**
   * Дефолтная конфигурация тултипа - всегда показывается по умолчанию.
   * При добавлении/изменении полей в конфиге - они объединяются с дефолтными значениями.
   *
   * Полная кастомизация:
   * @example
   * ```typescript
   *    tooltipConfig: {
   *      time: { visible: true, label: 'Дата и время' },
   *      symbol: { visible: true, label: 'Инструмент' },
   *      close: { visible: true, label: 'Курс' },
   *      change: { visible: true, label: 'Изменение' },
   *      volume: { visible: true, label: 'Объем' },
   *      open: { visible: false },
   *      high: { visible: false },
   *      low: { visible: false }
   *    }
   *```
   */
  tooltipConfig?: TooltipConfig;

  size?:
    | {
        width: number;
        height: number;
      }
    | false;

  supportedTimeframes: Timeframes[];
  supportedChartSeriesTypes: ChartSeriesType[];

  getDataSource: DataSourceParams['getData'];

  startRealtime: (
    getSymbols: () => string[],
    getTimeframe: () => Timeframes,
    update: (symbolId: string, candle: Candle) => void,
    periodMs?: number,
  ) => () => void;

  theme: ThemeKey; // 'mb' | 'mxt' | 'tr'
  ohlc: OHLCConfig;
  locale: Locale;
  mode?: ThemeMode; // 'light' | 'dark'

  openCompareModal?: () => void;
  openSymbolSearchModal?: () => void;
}

export interface IMoexChart {
  snapshot: MoexChartSnapshotInput;
  chartCollectionPreset: ChartCollectionPreset;

  container: HTMLElement;
  lwcInheritedChartOptions?: ChartTypeOptions;
}

export class MoexChart implements ISerializable<MoexChartSnapshot> {
  private chart!: Chart;
  private seasonalityManager!: SeasonalityManager;

  private inheritedChartOptions?: ChartTypeOptions;
  private resizeObserver?: ResizeObserver;

  private eventManager!: EventManager;
  private hotkeys!: Hotkeys;
  private rootContainer!: HTMLElement;

  private seasonalityControlsRenderer!: UIRenderer;
  private headerRenderer!: UIRenderer;
  private modalRenderer!: ModalRenderer;
  private toolbarRenderer: UIRenderer | undefined;
  private controlBarRenderer?: UIRenderer;
  private footerRenderer?: UIRenderer;
  private drawingToolbarRenderer!: UIRenderer;

  private timeScaleHoverController!: TimeScaleHoverController;
  private dataSource!: DataSource;

  private subscriptions = new Subscription();

  private fullscreen!: FullscreenController;

  private chartCollectionPresetSettings!: ChartCollectionPreset;

  constructor(config: IMoexChart) {
    setLocale(config.chartCollectionPreset.locale);
    this.setup(config);
  }

  private setup = (config: IMoexChart) => {
    this.subscriptions = new Subscription();

    this.toolbarRenderer = undefined;
    this.controlBarRenderer = undefined;
    this.footerRenderer = undefined;

    this.inheritedChartOptions = config.lwcInheritedChartOptions;
    this.chartCollectionPresetSettings = config.chartCollectionPreset;

    setPricePrecision(config.chartCollectionPreset.ohlc.precision);

    const { chartSeriesType, symbolId, symbol, symbolName, timeframe, interval, dateFormat, timeFormat } =
      config.snapshot.charts[0];

    this.eventManager = new EventManager({
      initialTimeframe: timeframe,
      initialSeries: chartSeriesType,
      initialSymbolInfo: {
        symbolId: symbolId ?? '',
        symbol,
        symbolName,
      },
      initialTimeFormat: timeFormat,
      initialDateFormat: dateFormat,
      initialInterval: interval,
    });

    // todo: сюда прокидывается не подходящий под сигнатуру интерфейс. Функция не работает
    // if (config.lwcInheritedChartOptions) {
    //   this.setSettings(config.lwcInheritedChartOptions);
    // }

    this.dataSource = new DataSource({
      getData: config.chartCollectionPreset.getDataSource,
      eventManager: this.eventManager,
    });

    this.rootContainer = config.container;

    this.fullscreen = new FullscreenController(this.rootContainer);

    const store = configureThemeStore(config.chartCollectionPreset);

    const {
      chartAreaContainer,
      chartContainer,
      seasonalityContainer,
      seasonalityControlsContainer,
      seasonalityPlotContainer,
      toolBarContainer,
      headerContainer,
      modalContainer,
      controlBarContainer,
      drawingToolbarContainer,
      footerContainer,
      toggleToolbar, // todo: move this function to toolbarModel
    } = ContainerManager.createContainers({
      parentContainer: this.rootContainer,
      showBottomPanel: config.chartCollectionPreset.showBottomPanel, // todo: apply config.showBottomPanel in FullscreenController
      showMenuButton: config.chartCollectionPreset.showMenuButton,
    });

    this.hotkeys = new Hotkeys(this.rootContainer, () => !this.seasonalityManager.isActive());

    if (config.chartCollectionPreset.undoRedoEnabled) {
      const undoRedo = this.eventManager.getUndoRedo();

      this.hotkeys.register({
        keys: [Keys.mod, Keys.z],
        callback: undoRedo.undo,
      });

      this.hotkeys.register({
        keys: [Keys.mod, Keys.y],
        callback: undoRedo.redo,
      });

      this.hotkeys.register({
        keys: [Keys.mod, Keys.shift, Keys.z],
        callback: undoRedo.redo,
      });
    }

    this.modalRenderer = new ModalRenderer(modalContainer);

    this.chart = new Chart({
      params: {
        dataSource: this.dataSource,
        eventManager: this.eventManager,
        modalRenderer: this.modalRenderer,
        ohlcConfig: config.chartCollectionPreset.ohlc, // todo: omptimize
        tooltipConfig: config.chartCollectionPreset.tooltipConfig ?? {},
        panes: config.snapshot.charts[0].panes,
        hotkeys: this.hotkeys,
      },
      lwcChartConfig: {
        container: chartAreaContainer,
        seriesTypes: config.chartCollectionPreset.supportedChartSeriesTypes,
        theme: store.theme,
        mode: store.mode,
        chartOptions: config.lwcInheritedChartOptions, // todo: remove, use only model from eventManager
      },
    });

    const chartGridTemplateRows = this.rootContainer.style.gridTemplateRows;

    const setSeasonalityVisible = (visible: boolean): void => {
      Object.assign(this.rootContainer.style, {
        gridTemplateRows: visible ? 'auto minmax(0, 1fr)' : chartGridTemplateRows,
      });

      Object.assign(chartContainer.style, {
        visibility: visible ? 'hidden' : 'visible',
      });

      chartContainer.inert = visible;

      Object.assign(footerContainer.style, {
        display: visible ? 'none' : '',
      });

      Object.assign(seasonalityContainer.style, {
        visibility: visible ? 'visible' : 'hidden',
        pointerEvents: visible ? 'auto' : 'none',
      });

      seasonalityContainer.inert = !visible;
    };

    this.seasonalityManager = new SeasonalityManager({
      container: seasonalityPlotContainer,
      getData: config.chartCollectionPreset.getDataSource,
      precision: config.chartCollectionPreset.ohlc.precision,

      onOpen: () => {
        this.chart.setActive(false);
        setSeasonalityVisible(true);
        seasonalityContainer.focus({ preventScroll: true });
      },

      onBack: () => {
        setSeasonalityVisible(false);
        this.chart.setActive(true);
        chartAreaContainer.focus({ preventScroll: true });
      },
    });

    this.seasonalityControlsRenderer = new ReactRenderer(seasonalityControlsContainer);

    this.seasonalityControlsRenderer.renderComponent(
      <SeasonalityControls
        stateObs={this.seasonalityManager.getState()}
        setScale={this.seasonalityManager.setScale}
        setRange={this.seasonalityManager.setRange}
      />,
    );

    this.subscriptions.add(
      this.hotkeys.register({
        keys: [Keys.escape],
        enabled: () => this.seasonalityManager.isActive() && modalContainer.hidden,
        callback: this.backToChart,
      }),
    );

    this.subscriptions.add(this.eventManager.symbolId().subscribe(this.backToChart));

    this.subscriptions.add(
      combineLatest([store.theme$, store.mode$]).subscribe(([theme, mode]) => {
        this.chart.updateTheme(theme, mode);
        this.seasonalityManager.updateTheme();

        document.documentElement.dataset.theme = theme;
        document.documentElement.dataset.mode = mode;
      }),
    );

    const realtimeParams = this.chart.getRealtimeApi();

    this.subscriptions.add(
      config.chartCollectionPreset.startRealtime(
        realtimeParams.getSymbols,
        realtimeParams.getTimeframe,
        realtimeParams.update,
      ),
    );

    this.headerRenderer = new ReactRenderer(headerContainer);
    this.toolbarRenderer = new ReactRenderer(toolBarContainer);
    this.drawingToolbarRenderer = new ReactRenderer(drawingToolbarContainer);

    if (config.chartCollectionPreset.showControlBar) {
      this.controlBarRenderer = new ReactRenderer(controlBarContainer);
    }

    if (config.chartCollectionPreset.showBottomPanel) {
      this.footerRenderer = new ReactRenderer(footerContainer);
    }

    this.timeScaleHoverController = new TimeScaleHoverController({
      eventManager: this.eventManager,
      controlBarContainer,
      chartContainer: chartAreaContainer,
    });

    this.renderAttachments(config, toggleToolbar);
  };

  public setSettings(settings: ChartSettingsSource): void {
    this.seasonalityManager.back();

    this.eventManager.importChartSettings(settings);
  }

  public getSettings(): ChartSettings {
    return this.eventManager.exportChartSettings();
  }

  // todo: описать подробнее в доке. Точно ли public?
  public getRealtimeApi() {
    return this.chart.getRealtimeApi();
  }

  // todo: описать подробнее в доке
  public getCompareManager(): CompareManager {
    return this.chart.getCompareManager();
  }

  public setSnapshot(snapshot: MoexChartSnapshotInput) {
    const configConstructorLike: IMoexChart = {
      snapshot,
      chartCollectionPreset: this.chartCollectionPresetSettings,
      container: this.rootContainer,
      lwcInheritedChartOptions: this.inheritedChartOptions,
    };

    this.destroy();
    this.setup(configConstructorLike);
  }

  // todo: описать в доке
  public getSnapshot(): MoexChartSnapshot {
    const res = {
      settings: this.getSettings(),
      charts: [this.chart.getSnapshot()], // todo: в будущем может быть несколько инстансов чартов
    };

    return res;
  }

  public setSymbol(symbolInfo: SymbolInfoInput): void {
    this.seasonalityManager.back();

    this.eventManager.setSymbol(symbolInfo);
  }

  public clearSymbol(): void {
    this.seasonalityManager.back();

    this.eventManager.clearSymbol();
  }

  public showSeasonality(range?: SeasonalityRange): Promise<void> {
    const { symbolInfo } = this.eventManager.exportChartSettings();

    return this.seasonalityManager.show(symbolInfo.symbolId, range);
  }

  public backToChart = (): void => {
    this.seasonalityManager.back();
  };

  private setChartView = (view: ChartViewType): void => {
    if (view === ChartViewType.Chart) {
      this.backToChart();
      return;
    }

    this.showSeasonality();
  };

  private renderAttachments(config: IMoexChart, toggleToolbar: () => boolean) {
    const drawingsCollectionManager = this.chart.getDrawingsCollectionManager();

    this.drawingToolbarRenderer.renderComponent(
      // этот тулбар к drawingManger бы прибить, сильно на него завязан
      <FloatingDrawingToolbar
        selectedDrawing$={drawingsCollectionManager.selectedDrawing()}
        onUpdateSettings={drawingsCollectionManager.updateSelectedDrawingSettings}
        onToggleLock={() => drawingsCollectionManager.toggleSelectedDrawingLock()}
        onOpenSettings={() => drawingsCollectionManager.openSelectedDrawingSettings()}
        onDelete={() => drawingsCollectionManager.deleteSelectedDrawing()}
      />,
    );

    this.headerRenderer.renderComponent(
      <Header
        seasonalityStateObs={this.seasonalityManager.getState()}
        setChartView={config.chartCollectionPreset.showSeasonalityButton ? this.setChartView : undefined}
        timeframes={config.chartCollectionPreset.supportedTimeframes}
        selectedTimeframeObs={this.eventManager.getTimeframeObs()}
        setTimeframe={(value) => {
          this.eventManager.setTimeframe(value);
        }}
        seriesTypes={config.chartCollectionPreset.supportedChartSeriesTypes}
        selectedSeriesObs={this.eventManager.getSelectedSeries()}
        setSelectedSeries={(value) => {
          this.eventManager.setSeriesSelected(value);
        }}
        showSettingsModal={
          config.chartCollectionPreset.showSettingsButton
            ? () =>
                this.modalRenderer.renderComponent(
                  <SettingsModal
                    // todo: deal with onSave
                    changeTimeFormat={(format) => this.eventManager.setTimeFormat(format)}
                    changeDateFormat={(format) => this.eventManager.setDateFormat(format)}
                    chartDateTimeFormatObs={this.eventManager.getChartOptionsModel()}
                  />,
                  { title: t('Settings') },
                )
            : undefined
        }
        addIndicatorToChart={(indicatorType: IndicatorsIds) =>
          this.chart.getIndicatorManager().addIndicator({ indicatorType })
        }
        copyImage={
          config.chartCollectionPreset.showSnapshotButton
            ? () => (this.seasonalityManager.isActive() ? this.seasonalityManager.copyImage() : this.chart.copyImage())
            : undefined
        }
        showMenuButton={!!config.chartCollectionPreset.showMenuButton}
        showFullscreenButton={!!config.chartCollectionPreset.showFullscreenButton}
        fullscreen={this.fullscreen}
        undoRedo={config.chartCollectionPreset.undoRedoEnabled ? this.eventManager.getUndoRedo() : undefined}
        toggleToolbarVisible={toggleToolbar}
        showCompareButton={!!config.chartCollectionPreset.showCompareButton}
        openCompareModal={
          config.chartCollectionPreset.openCompareModal ? config.chartCollectionPreset.openCompareModal : undefined
        }
        showSymbolSearchButton={!!config.chartCollectionPreset.openSymbolSearchModal}
        openSymbolSearchModal={config.chartCollectionPreset.openSymbolSearchModal}
        isMXT={config.chartCollectionPreset.theme === 'mxt'}
      />,
    );

    if (this.toolbarRenderer && config.chartCollectionPreset.showMenuButton) {
      const drawingCollection = this.chart.getDrawingsCollectionManager();

      this.toolbarRenderer.renderComponent(
        <Toolbar
          toggleDOM={this.chart.getDom().toggleDOM}
          addDrawing={drawingCollection.activateDrawingTool}
          setEndlessDrawingsMode={drawingCollection.setEndlessDrawingMode}
          isEndlessDrawingsMode$={drawingCollection.isEndlessDrawingsMode()}
          activateCrosshair={() => drawingCollection.activateCrosshair()}
          activeTool$={drawingCollection.getActiveTool()}
        />,
      );
    }

    if (this.controlBarRenderer && config.chartCollectionPreset.showControlBar) {
      this.controlBarRenderer.renderComponent(
        <ControlBar
          scroll={this.chart.scrollTimeScale}
          zoom={this.chart.zoomTimeScale}
          reset={this.chart.resetZoom}
          visible={this.eventManager.getControlBarVisible()}
        />,
      );
    }

    if (this.footerRenderer && config.chartCollectionPreset.showBottomPanel) {
      this.footerRenderer.renderComponent(
        <Footer
          supportedTimeframes={config.chartCollectionPreset.supportedTimeframes}
          setInterval={this.eventManager.setInterval}
          intervalObs={this.eventManager.getInterval()}
        />,
      );
    }
  }

  /**
   * Уничтожение графика и очистка ресурсов
   * @returns void
   */
  destroy(): void {
    this.seasonalityControlsRenderer.destroy();
    this.seasonalityManager.destroy();

    this.headerRenderer.destroy();
    this.drawingToolbarRenderer.destroy();

    this.subscriptions.unsubscribe();
    this.timeScaleHoverController.destroy();

    if (this.resizeObserver) {
      this.resizeObserver.disconnect();
      this.resizeObserver = undefined;
    }

    if (this.controlBarRenderer) {
      this.controlBarRenderer.destroy();
    }

    if (this.footerRenderer) {
      this.footerRenderer.destroy();
    }

    if (this.chart) {
      this.chart.destroy();
    }

    this.hotkeys.destroy();

    if (this.eventManager) {
      this.eventManager.destroy();
    }

    if (this.toolbarRenderer) {
      this.toolbarRenderer.destroy();
    }

    this.dataSource.destroy();

    ContainerManager.clearContainers(this.rootContainer);
  }
}