candleview 1.0.0

package/dist/components/CandleView/ChartLayer/SubChart/Stochastic.d.ts

@@ -0,0 +1,23 @@
+import { MouseEventParams } from "lightweight-charts";
+import { IIndicatorInfo } from "../../Indicators/SubChart/IIndicator";
+import { BaseChartPane } from "../Panes/BaseChartPane";
+export declare class Stochastic extends BaseChartPane {
+    private seriesMap;
+    private stochasticIndicator;
+    private currentValues;
+    private stochasticIndicatorInfo;
+    init(chartData: any[], settings?: IIndicatorInfo[]): void;
+    updateSettings(chartData: any[], settings?: IIndicatorInfo[]): void;
+    getParams(): IIndicatorInfo[];
+    private getCurrentValue;
+    private updateInfoParams;
+    protected getPriceScaleOptions(): any;
+    updateData(chartData: any[]): void;
+    getSeries(): {
+        [key: string]: any;
+    };
+    updateIndicatorSettings(settings: IIndicatorInfo): void;
+    getIndicatorSettings(): IIndicatorInfo | null;
+    destroy(): void;
+    handleCrosshairMoveEvent(event: MouseEventParams): void;
+}

package/dist/components/CandleView/ChartLayer/SubChart/Volume.d.ts

@@ -0,0 +1,24 @@
+import { MouseEventParams } from "lightweight-charts";
+import { IIndicatorInfo } from "../../Indicators/SubChart/IIndicator";
+import { BaseChartPane } from "../Panes/BaseChartPane";
+export declare class Volume extends BaseChartPane {
+    private seriesMap;
+    private volumeIndicator;
+    private currentValues;
+    private _default;
+    private volumeIndicatorInfo;
+    init(chartData: any[], settings?: IIndicatorInfo[]): void;
+    updateSettings(chartData: any[], settings?: IIndicatorInfo[]): void;
+    getParams(): IIndicatorInfo[];
+    private getCurrentValue;
+    private updateInfoParams;
+    protected getPriceScaleOptions(): any;
+    updateData(chartData: any[]): void;
+    getSeries(): {
+        [key: string]: any;
+    };
+    updateIndicatorSettings(settings: IIndicatorInfo): void;
+    getIndicatorSettings(): IIndicatorInfo | null;
+    destroy(): void;
+    handleCrosshairMoveEvent(event: MouseEventParams): void;
+}

package/dist/components/CandleView/ChartLayer/ToolBar/GraphMarkToolBar.d.ts

@@ -0,0 +1,51 @@
+import React from 'react';
+import { MarkDrawing, Point } from '../../types';
+import { ThemeConfig } from '../../Theme';
+import { I18n } from '../../I18n';
+interface GraphMarkToolBarProps {
+    position: Point;
+    selectedDrawing: MarkDrawing | null;
+    theme: ThemeConfig;
+    onClose: () => void;
+    onDelete: () => void;
+    onChangeColor: (color: string) => void;
+    onChangeStyle: (lineStyle: 'solid' | 'dashed' | 'dotted') => void;
+    onChangeWidth: (width: number) => void;
+    onEditText?: () => void;
+    onDragStart: (point: Point) => void;
+    isDragging: boolean;
+    getToolName: (toolId: string) => string;
+    onPanelChange?: (panel: 'color' | 'style' | null) => void;
+    i18n: I18n;
+}
+interface GraphMarkToolBarState {
+    activePanel: 'color' | 'style' | 'lineSize' | 'lineStyle' | null;
+    lineWidth: number;
+    lineStyle: 'solid' | 'dashed' | 'dotted';
+    isBold: boolean;
+    isItalic: boolean;
+    currentColor: string;
+}
+export declare class GraphMarkToolBar extends React.Component<GraphMarkToolBarProps, GraphMarkToolBarState> {
+    private toolbarRef;
+    constructor(props: GraphMarkToolBarProps);
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    componentDidUpdate(prevProps: GraphMarkToolBarProps): void;
+    private handleDocumentClick;
+    private stopPropagation;
+    private handleDragStart;
+    private handleButtonClick;
+    private handleClosePanel;
+    private handleColorChange;
+    private handleLineSizeChange;
+    private handleLineStyleChange;
+    private renderDragHandle;
+    private renderIconButton;
+    private renderColorPanel;
+    private renderLineSizeDropdown;
+    private renderLineStyleDropdown;
+    private renderMainToolbar;
+    render(): React.JSX.Element | null;
+}
+export {};

package/dist/components/CandleView/ChartLayer/ToolBar/TextMarkToolBar.d.ts

@@ -0,0 +1,65 @@
+import React from 'react';
+import { MarkDrawing, Point } from '../../types';
+import { ThemeConfig } from '../../Theme';
+import { I18n } from '../../I18n';
+interface TextMarkToolBarProps {
+    position: Point;
+    selectedDrawing: MarkDrawing | null;
+    theme: ThemeConfig;
+    onClose: () => void;
+    onDelete: () => void;
+    onChangeTextColor: (color: string) => void;
+    onChangeTextStyle: (style: {
+        isBold?: boolean;
+        isItalic?: boolean;
+    }) => void;
+    onChangeTextSize: (size: number) => void;
+    onChangeGraphColor: (color: string) => void;
+    onChangeGraphStyle: (lineStyle: 'solid' | 'dashed' | 'dotted') => void;
+    onChangeGraphLineWidth: (width: number) => void;
+    onEditText?: () => void;
+    onDragStart: (point: Point) => void;
+    isDragging: boolean;
+    getToolName: (toolId: string) => string;
+    onPanelChange?: (panel: 'color' | 'style' | null) => void;
+    isShowGrapTool?: boolean;
+    i18n: I18n;
+}
+interface TextMarkToolBarState {
+    activePanel: 'color' | 'style' | 'fontSize' | 'graphColor' | 'graphLineSize' | 'graphLineStyle' | null;
+    fontSize: number;
+    isBold: boolean;
+    isItalic: boolean;
+    fontColor: string;
+    graphColor: string;
+    graphWidth: number;
+    graphStyle: 'solid' | 'dashed' | 'dotted';
+}
+export declare class TextMarkToolBar extends React.Component<TextMarkToolBarProps, TextMarkToolBarState> {
+    private toolbarRef;
+    constructor(props: TextMarkToolBarProps);
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    private handleDocumentClick;
+    private stopPropagation;
+    private handleDragStart;
+    private handleButtonClick;
+    private handleClosePanel;
+    private handleColorChange;
+    private handleFontSizeChange;
+    private handleGraphColorChange;
+    private handleGraphStyleChange;
+    private handleGraphLineWidthChange;
+    private toggleBold;
+    private toggleItalic;
+    private renderGraphColorPanel;
+    private renderGraphLineSizeDropdown;
+    private renderGraphLineStyleDropdown;
+    private renderDragHandle;
+    private renderIconButton;
+    private renderColorPanel;
+    private renderFontSizePanel;
+    renderMainToolbar(): React.JSX.Element;
+    render(): React.JSX.Element | null;
+}
+export {};

package/dist/components/CandleView/ChartLayer/index.d.ts

@@ -0,0 +1,291 @@
+/// <reference types="node" />
+import React from 'react';
+import { ThemeConfig } from '../Theme';
+import { ChartSeries } from './ChartTypeManager';
+import { CursorType, HistoryRecord, ICandleViewDataPoint, MainChartIndicatorType, MainChartType, MarkDrawing, Point, SubChartIndicatorType } from '../types';
+import { IMarkStyle } from '../Mark/IMarkStyle';
+import { ChartMarkManager } from './ChartMarkManager';
+import { ChartMarkTextEditManager } from './ChartMarkTextEditManager';
+import { MainChartTechnicalIndicatorManager } from '../Indicators/MainChart/MainChartIndicatorManager';
+import { ChartMarkState } from './ChartLayerMarkState';
+import { MainChartIndicatorInfo } from '../Indicators/MainChart/MainChartIndicatorInfo';
+import { I18n } from '../I18n';
+import { IStaticMarkData } from '../MarkManager/StaticMarkManager';
+import { ChartPanesManager } from './Panes/ChartPanesManager';
+import { IIndicatorInfo } from '../Indicators/SubChart/IIndicator';
+import { MainChartManager } from './MainChart/MainChartManager';
+import { ViewportManager } from '../ViewportManager';
+export interface ChartLayerProps {
+    chart: any;
+    chartSeries: ChartSeries | null;
+    currentTheme: ThemeConfig;
+    activeTool: string | null;
+    onCloseDrawing?: () => void;
+    onToolSelect?: (tool: string) => void;
+    onTextClick?: (toolId: string) => void;
+    onEmojiClick?: (toolId: string) => void;
+    selectedEmoji?: string;
+    chartData: ICandleViewDataPoint[];
+    title?: string;
+    selectedMainChartIndicator: MainChartIndicatorInfo | null;
+    selectedSubChartIndicators: SubChartIndicatorType[];
+    handleRemoveSubChartIndicator?: (type: SubChartIndicatorType) => void;
+    showInfoLayer: boolean;
+    i18n: I18n;
+    markData?: IStaticMarkData[];
+    onMainChartIndicatorChange: (indicator: MainChartIndicatorInfo | null) => void;
+    currentMainChartType: MainChartType;
+    viewportManager: ViewportManager | null;
+}
+export interface ChartLayerState extends ChartMarkState {
+    isDrawing: boolean;
+    drawingPoints: Point[];
+    currentDrawing: any;
+    drawingStartPoint: Point | null;
+    drawings: MarkDrawing[];
+    isTextMarkToolbar: boolean;
+    dragStartPoint: Point | null;
+    history: HistoryRecord[];
+    historyIndex: number;
+    isDragging: boolean;
+    isResizing: boolean;
+    isRotating: boolean;
+    resizeHandle: string | null;
+    isTextInputActive: boolean;
+    textInputPosition: Point | null;
+    textInputValue: string;
+    textInputCursorVisible: boolean;
+    textInputCursorTimer: NodeJS.Timeout | null;
+    activePanel: null;
+    editingTextId: string | null;
+    isFirstTimeTextMode: boolean;
+    isEmojiInputActive: boolean;
+    emojiInputPosition: Point | null;
+    editingEmojiId: string | null;
+    mousePosition: Point | null;
+    currentOHLC: {
+        time: string;
+        open: number;
+        high: number;
+        low: number;
+        close: number;
+        volume?: number;
+    } | null;
+    showOHLC: boolean;
+    maIndicatorValues?: {
+        [key: string]: number;
+    };
+    emaIndicatorValues?: {
+        [key: string]: number;
+    };
+    bollingerBandsValues?: {
+        [key: string]: number;
+    };
+    ichimokuValues?: {
+        [key: string]: number;
+    };
+    donchianChannelValues?: {
+        [key: string]: number;
+    };
+    envelopeValues?: {
+        [key: string]: number;
+    };
+    vwapValue?: number | null;
+    isMainChartIndicatorsModalOpen: boolean;
+    selectedMainChartIndicators: MainChartIndicatorInfo[];
+    selectedMainChartIndicatorTypes: MainChartIndicatorType[];
+    modalEditingChartInfoIndicator: MainChartIndicatorInfo | null;
+    modalConfirmChartInfoIndicators: MainChartIndicatorInfo[];
+    isSubChartIndicatorsSettingModalOpen: boolean;
+    subChartIndicatorsSettingModalParams: IIndicatorInfo[];
+    currentSubChartIndicatorType: SubChartIndicatorType | null;
+    cursorType: CursorType | null;
+}
+declare class ChartLayer extends React.Component<ChartLayerProps, ChartLayerState> {
+    canvasRef: React.RefObject<HTMLCanvasElement>;
+    containerRef: React.RefObject<HTMLDivElement>;
+    allDrawings: MarkDrawing[];
+    private doubleClickTimeout;
+    private chartEventManager;
+    private originalChartOptions;
+    currentMarkSettingsStyle: IMarkStyle | null;
+    chartMarkManager: ChartMarkManager | null;
+    chartMarkTextEditManager: ChartMarkTextEditManager | null;
+    mainChartTechnicalIndicatorManager: MainChartTechnicalIndicatorManager | null;
+    private staticMarkManager;
+    chartPanesManager: ChartPanesManager | null;
+    private volume;
+    private volumeHeatMap;
+    private marketProfile;
+    mainChartManager: MainChartManager | null;
+    constructor(props: ChartLayerProps);
+    componentDidMount(): void;
+    componentDidUpdate(prevProps: ChartLayerProps): void;
+    componentWillUnmount(): void;
+    private handleInitMainChartMaps;
+    private handleUpdateMainChartMaps;
+    private hasChartDataChanged;
+    private hasMainChartIndicatorChanged;
+    private initStaticMark;
+    private updateStaticMark;
+    private swtichMainChartType;
+    setCursorType: (cursorType: CursorType) => void;
+    private initializeMainChartIndicators;
+    private updateAllMainChartIndicatorData;
+    private updateMainChartIndicators;
+    private updateSelectedMainChartIndicators;
+    private handleOpenIndicatorSettings;
+    private handleMainChartIndicatorsSettingConfirm;
+    private handleRemoveIndicator;
+    setMockKLineMarkMode: () => void;
+    private initializeGraphManager;
+    private initializeGraphManagerProps;
+    private destroyGraphManager;
+    showAllMark: () => void;
+    hideAllMark: () => void;
+    clearAllMark: () => void;
+    setSchiffPitchforkMode: () => void;
+    setHeatMapMode: () => void;
+    setTextEditMarkMode: () => void;
+    setBubbleBoxMarkMode: () => void;
+    setPinMarkMode: () => void;
+    setEmojiMarkMode: (emoji: string) => void;
+    setSignpostMarkMode: () => void;
+    setPriceNoteMarkMode: () => void;
+    setFlagMarkMode: () => void;
+    setPriceLabelMode: () => void;
+    setShortPositionMarkMode: () => void;
+    setLongPositionMarkMode: () => void;
+    setThickArrowLineMode: () => void;
+    setEraserMode: () => void;
+    setMarkerPenMode: () => void;
+    setBrushMode: () => void;
+    setPenMode: () => void;
+    setPencilMode: () => void;
+    setTimePriceRangeMarkMode: () => void;
+    setPriceRangeMarkMode: () => void;
+    setTimeRangeMarkMode: () => void;
+    setElliottTripleCombinationMode: () => void;
+    setElliottDoubleCombinationMode: () => void;
+    setElliottTriangleMode: () => void;
+    setElliottCorrectiveMode: () => void;
+    setElliottImpulseMode: () => void;
+    setTriangleABCDMode: () => void;
+    setABCDMode: () => void;
+    setHeadAndShouldersMode: () => void;
+    setXABCDMode: () => void;
+    setDoubleCurveMode: () => void;
+    setCurveMode: () => void;
+    setSectorMode: () => void;
+    setFibonacciExtensionBaseTimeMode: () => void;
+    setFibonacciExtensionBasePriceMode: () => void;
+    setFibonacciChannelMode: () => void;
+    setFibonacciFanMode: () => void;
+    setFibonacciWedgeMode: () => void;
+    setFibonacciSpiralMode: () => void;
+    setFibonacciCircleMode: () => void;
+    setFibonacciArcMode: () => void;
+    setFibonacciRetracementMode: () => void;
+    setFibonacciTimeZoonMode: () => void;
+    setGannRectangleMode: () => void;
+    setGannBoxMode: () => void;
+    setGannFanMode: () => void;
+    setTriangleMarkMode: () => void;
+    setEllipseMarkMode: () => void;
+    setCircleMarkMode: () => void;
+    setRectangleMarkMode: () => void;
+    setEnhancedAndrewPitchforkMode: () => void;
+    setAndrewPitchforkMode: () => void;
+    setDisjointChannelMarkMode: () => void;
+    setEquidistantChannelMarkMode: () => void;
+    setLinearRegressionChannelMode: () => void;
+    setLineSegmentMarkMode: () => void;
+    setHorizontalLineMode: () => void;
+    setVerticalLineMode: () => void;
+    setArrowLineMarkMode: () => void;
+    setParallelChannelMarkMode: () => void;
+    showGraphMarkToolBar: (drawing: MarkDrawing) => void;
+    closeGraphMarkToolBar: () => void;
+    showTableMarkToolBar: (drawing: MarkDrawing) => void;
+    closeTableMarkToolBar: () => void;
+    showTextEditMarkToolBar: (drawing: MarkDrawing, isShowGrapTool: boolean) => void;
+    closeTextMarkToolBar: () => void;
+    private setupAllContainerEvents;
+    private cleanupAllContainerEvents;
+    private setupAllDocumentEvents;
+    private cleanupAllDocumentEvents;
+    private handleMouseDown;
+    private handleMouseUp;
+    private handleMouseMove;
+    serializeDrawings(): string;
+    handleViewportShiftLeft: () => void;
+    handleViewportShiftRight: () => void;
+    handleZoomIn: () => void;
+    handleZoomOut: () => void;
+    openIndicatorsModal: () => void;
+    private handleToggleIndicator;
+    private renderChartInfo;
+    private handleIndicatorsClose;
+    setImageMarkMode: () => void;
+    private handleImageConfirm;
+    private handleImageUploadClose;
+    private setSelectedImageUrl;
+    private handleChangeTextMarkFontColor;
+    private handleChangeTextMarkStyle;
+    private handleChangeTextMarkFontSize;
+    private handleChangeTextMarkGraphColor;
+    private handleChangeTextMarkGraphLineStyle;
+    private handleChangeTextMarkGraphLineWidth;
+    private handleDeleteTextEditMark;
+    private handleTextMarkEditorSave;
+    private handleTextMarkEditorCancel;
+    private handleDeleteGraphMark;
+    private handleChangeGraphMarkColor;
+    private handleChangeGraphMarkStyle;
+    private handleChangeGraphMarkWidth;
+    private handleGraphToolbarDrag;
+    private handleKeyDown;
+    private setupCanvas;
+    private handleDocumentMouseUp;
+    private handleDocumentMouseDown;
+    private handleDocumentMouseMove;
+    private handleDocumentMouseWheel;
+    getDrawingLayerElementsPosition(): Array<{
+        id: string;
+        type: string;
+        position: {
+            x: number;
+            y: number;
+        };
+        element?: HTMLElement;
+    }>;
+    setDrawingLayerElementsPosition(positions: Array<{
+        id: string;
+        type: string;
+        position: {
+            x: number;
+            y: number;
+        };
+    }>): void;
+    moveDrawingLayerElements(deltaX: number, deltaY: number): void;
+    getDrawingLayerElementsByType(type: 'text' | 'emoji'): Array<{
+        id: string;
+        position: {
+            x: number;
+            y: number;
+        };
+        element: HTMLElement;
+    }>;
+    private handleTextMarkToolBarDrag;
+    private getToolName;
+    private toggleOHLCVisibility;
+    disableChartMovement(): void;
+    enableChartMovement(): void;
+    private renderMainChart;
+    showSubChartSettingModal: (initialParams: IIndicatorInfo[] | undefined, subChartIndicatorType: SubChartIndicatorType) => void;
+    private handleSubChartSettingClose;
+    private handleSubChartSettingConfirm;
+    render(): React.JSX.Element;
+}
+export { ChartLayer };
+export type { MarkDrawing };

package/dist/components/CandleView/DataAdapter.d.ts

@@ -0,0 +1,28 @@
+import { I18n } from "./I18n";
+import { ICandleViewDataPoint, TimeframeEnum, TimezoneEnum } from "./types";
+export interface TimeframeConfig {
+    seconds: number;
+    groupBy: 'second' | 'minute' | 'hour' | 'day' | 'week' | 'month';
+}
+export interface TimeConfig {
+    timeframe?: TimeframeEnum;
+    timezone?: TimezoneEnum;
+}
+export declare const TIMEFRAME_CONFIGS: {
+    [key: string]: TimeframeConfig;
+};
+export declare function getTimeframeDisplayName(timeframe: string, i18n: I18n): string;
+export declare function generateExtendedVirtualData(originalData: ICandleViewDataPoint[], beforeCount: number, afterCount: number, timeframe?: string): ICandleViewDataPoint[];
+export declare function convertTimeZone(data: ICandleViewDataPoint[], timezone: TimezoneEnum): ICandleViewDataPoint[];
+export interface TimeZoneConfig {
+    name: string;
+    offset: string;
+    displayName: string;
+}
+export declare const TIMEZONE_CONFIGS: {
+    [key in TimezoneEnum]: TimeZoneConfig;
+};
+export declare function aggregateForTimeFrame(data: ICandleViewDataPoint[], timeframe: TimeframeEnum): ICandleViewDataPoint[];
+export declare function getTimeframeSeconds(timeframe: TimeframeEnum): number;
+export declare function createAggregatedCandle(group: ICandleViewDataPoint[]): ICandleViewDataPoint;
+export declare function fillMissingCandleTimeframe(timeframe: TimeframeEnum, data: ICandleViewDataPoint[]): ICandleViewDataPoint[];

package/dist/components/CandleView/DataLoader.d.ts

@@ -0,0 +1,15 @@
+import { ICandleViewDataPoint } from './types';
+export interface DataLoaderConfig {
+    jsonFilePath?: string;
+    data?: ICandleViewDataPoint[];
+    url?: string;
+}
+export declare class DataLoader {
+    static loadData(config: DataLoaderConfig): ICandleViewDataPoint[];
+    private static loadFromLocalFile;
+    private static loadFromUrl;
+    private static parseOHLCData;
+    private static validateAndFormatData;
+    static validateConfig(config: DataLoaderConfig): boolean;
+    static getActiveDataSource(config: DataLoaderConfig): string;
+}

package/dist/components/CandleView/DataManager.d.ts

@@ -0,0 +1,23 @@
+import { ICandleViewDataPoint, MainChartType, TimeframeEnum, TimezoneEnum } from './types';
+import { TimeConfig } from './DataAdapter';
+export interface DataProcessingConfig {
+    timeframe: TimeframeEnum;
+    timezone: TimezoneEnum;
+    shouldExtendVirtualData?: boolean;
+    virtualDataBeforeCount?: number;
+    virtualDataAfterCount?: number;
+    chartType?: string;
+}
+export declare function buildDefaultDataProcessingConfig(timeConfig: TimeConfig, chartType: MainChartType, virtualDataBeforeCount?: number, virtualDataAfterCount?: number): DataProcessingConfig;
+export declare class DataManager {
+    static handleData(originalData: ICandleViewDataPoint[], config: DataProcessingConfig, chartType: MainChartType): ICandleViewDataPoint[];
+    private static extendWithVirtualData;
+    private static calculateOptimalVirtualDataCount;
+    private static formatCache;
+    static handleChartDisplayData(data: ICandleViewDataPoint[], mainChartType: MainChartType): ICandleViewDataPoint[];
+    static filterRealData(data: ICandleViewDataPoint[]): ICandleViewDataPoint[];
+    static getTimeframeConfig(timeframe: TimeframeEnum): import("./DataAdapter").TimeframeConfig;
+    static validateData(data: ICandleViewDataPoint[]): boolean;
+    static sampleData(data: ICandleViewDataPoint[], sampleRate?: number): ICandleViewDataPoint[];
+}
+export declare const processChartData: (originalData: ICandleViewDataPoint[], config: DataProcessingConfig, chartType: MainChartType) => ICandleViewDataPoint[];

package/dist/components/CandleView/DataPointManager.d.ts

@@ -0,0 +1,45 @@
+import { ICandleViewDataPoint } from "./types";
+export declare class DataPointManager {
+    private static lastFirstRealDataInViewport;
+    private static lastLastRealDataInViewport;
+    private static lastFirstRealDataLeftViewport;
+    private static lastFirstRealDataRightViewport;
+    private static lastLastRealDataLeftViewport;
+    private static lastLastRealDataRightViewport;
+    private static lastFirstRealDataNearRightViewport;
+    private static lastLastRealDataNearLeftViewport;
+    static getRealDataRange(data: ICandleViewDataPoint[]): {
+        firstIndex: number;
+        lastIndex: number;
+    } | null;
+    static checkDataPointPositions(visibleLogicalRange: {
+        from: number;
+        to: number;
+    } | null, realDataRange: {
+        firstIndex: number;
+        lastIndex: number;
+    } | null, callbacks: {
+        onFirstRealDataExitLeftViewport?: () => void;
+        onFirstRealDataExitRightViewport?: () => void;
+        onLastRealDataExitLeftViewport?: () => void;
+        onLastRealDataExitRightViewport?: () => void;
+        onFirstRealDataExitViewport?: () => void;
+        onLastRealDataExitViewport?: () => void;
+        onFirstRealDataEnterLeftViewport?: () => void;
+        onFirstRealDataNearRightViewport?: () => void;
+        onLastRealDataNearLeftViewport?: () => void;
+        onFirstRealDataLeaveNearRightViewport?: () => void;
+        onLastRealDataLeaveNearLeftViewport?: () => void;
+    }): void;
+    static reset(): void;
+    static getCurrentState(): {
+        lastFirstRealDataInViewport: boolean;
+        lastLastRealDataInViewport: boolean;
+        lastFirstRealDataLeftViewport: boolean;
+        lastFirstRealDataRightViewport: boolean;
+        lastLastRealDataLeftViewport: boolean;
+        lastLastRealDataRightViewport: boolean;
+        lastFirstRealDataNearRightViewport: boolean;
+        lastLastRealDataNearLeftViewport: boolean;
+    };
+}