candleview 1.0.4 → 1.0.5

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

@@ -0,0 +1,16 @@
+import { CandleView } from './CandleView';
+export interface CaptureResult {
+    success: boolean;
+    dataUrl?: string;
+    blob?: Blob;
+    error?: string;
+    width: number;
+    height: number;
+    timestamp: number;
+}
+export type CaptureCallback = (result: CaptureResult) => void;
+export declare function captureWithCanvas(candleView: CandleView, callback?: CaptureCallback): Promise<CaptureResult>;
+export declare function drawHTMLElementsToCanvas(candleView: CandleView, container: HTMLElement, ctx: CanvasRenderingContext2D, width: number, height: number): void;
+export declare function drawElementToCanvas(candleView: CandleView, element: HTMLElement, ctx: CanvasRenderingContext2D, container: HTMLElement): void;
+export declare function drawElementContent(candleView: CandleView, element: HTMLElement, ctx: CanvasRenderingContext2D, width: number, height: number): void;
+export declare function wrapText(candleView: CandleView, ctx: CanvasRenderingContext2D, text: string, maxWidth: number): string[];

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

@@ -0,0 +1,149 @@
+import { default as React } from 'react';
+import { MainChartIndicatorInfo } from './Indicators/MainChart/MainChartIndicatorInfo';
+import { I18n } from './I18n';
+import { ICandleViewDataPoint, MainChartType, SubChartIndicatorType, TimeframeEnum, TimezoneEnum } from './types';
+import { IStaticMarkData } from './MarkManager/StaticMarkManager';
+import { ThemeConfig } from './Theme';
+export interface CandleViewProps {
+    theme?: 'dark' | 'light';
+    i18n?: 'en' | 'zh-cn';
+    showToolbar?: boolean;
+    showIndicators?: boolean;
+    height?: number | string;
+    title: string;
+    showTopPanel?: boolean;
+    showLeftPanel?: boolean;
+    markData?: IStaticMarkData[];
+    timeframe?: string;
+    timezone?: string;
+    data?: ICandleViewDataPoint[];
+    jsonFilePath?: string;
+    url?: string;
+    handleScreenshotCapture?: (imageData: {
+        dataUrl: string;
+        blob: Blob;
+        width: number;
+        height: number;
+        timestamp: number;
+    }) => void;
+}
+interface CandleViewState {
+    isIndicatorModalOpen: boolean;
+    isTimeframeModalOpen: boolean;
+    isTradeModalOpen: boolean;
+    isChartTypeModalOpen: boolean;
+    isSubChartModalOpen: boolean;
+    isMobileMenuOpen: boolean;
+    activeTool: string | null;
+    currentTheme: ThemeConfig;
+    currentI18N: I18n;
+    chartInitialized: boolean;
+    isDarkTheme: boolean;
+    selectedEmoji: string;
+    subChartPanelHeight: number;
+    isResizing: boolean;
+    showInfoLayer: boolean;
+    isTimezoneModalOpen: boolean;
+    currentTimezone: string;
+    isTimeFormatModalOpen: boolean;
+    isCloseTimeModalOpen: boolean;
+    isTradingDayModalOpen: boolean;
+    currentCloseTime: string;
+    currentTradingDayType: string;
+    activeTimeframe: TimeframeEnum;
+    timeframe?: TimeframeEnum;
+    timezone?: TimezoneEnum;
+    savedVisibleRange: {
+        from: number;
+        to: number;
+    } | null;
+    currentMainChartType: MainChartType;
+    selectedSubChartIndicators: SubChartIndicatorType[];
+    selectedMainChartIndicator: MainChartIndicatorInfo | null;
+    virtualDataBeforeCount: number;
+    virtualDataAfterCount: number;
+    displayData: ICandleViewDataPoint[];
+    isDataLoading: boolean;
+    dataLoadProgress: number;
+    loadError: string | null;
+}
+export declare class CandleView extends React.Component<CandleViewProps, CandleViewState> {
+    candleViewContainerRef: React.RefObject<HTMLDivElement | null>;
+    private chartRef;
+    private chartContainerRef;
+    private drawingLayerRef;
+    private chart;
+    private resizeObserver;
+    private realTimeInterval;
+    private currentSeries;
+    private chartManager;
+    private updateTimeout;
+    private viewportManager;
+    private chartEventManager;
+    private preparedData;
+    private originalData;
+    constructor(props: CandleViewProps);
+    componentDidMount(): void;
+    componentDidUpdate(prevProps: CandleViewProps, prevState: CandleViewState): void;
+    componentWillUnmount(): void;
+    private loadDataAsync;
+    private loadExternalData;
+    private loadInternalData;
+    initializeChart(): void;
+    handleTimeFormatClick: () => void;
+    handleCloseTimeClick: () => void;
+    handleTradingDayClick: () => void;
+    handleTimezoneClick: () => void;
+    handleCloseModals: () => void;
+    handleTimezoneSelect: (timezone: string) => void;
+    handleTimeframeSelect: (timeframe: string) => void;
+    private loadInternalDataAsync;
+    private initChart;
+    private refreshChart;
+    private refreshExternalData;
+    private refreshInternalData;
+    handleSelectedSubChartIndicator: (indicators: SubChartIndicatorType[]) => void;
+    handleRemoveSubChartIndicator: (indicatorId: string) => void;
+    handleCameraClick: () => void;
+    private fallbackToDownload;
+    serializeDrawings: () => string;
+    handleSubChartClick: () => void;
+    deserializeDrawings: (data: string) => void;
+    clearAllDrawings: () => void;
+    private viewportDataBufferSize;
+    private handleVisibleTimeRangeChange;
+    setupResizeObserver(): void;
+    updateChartTheme(): void;
+    getThemeConfig(theme: 'dark' | 'light'): ThemeConfig;
+    getI18nConfig(i18n: 'en' | 'zh-cn'): I18n;
+    handleEmojiSelect: (emoji: string) => void;
+    handleThemeToggle: () => void;
+    handleMobileMenuToggle: () => void;
+    handleClickOutside: (event: MouseEvent) => void;
+    handleToolSelect: (tool: string) => void;
+    handleChartTypeSelect: (mainChartType: MainChartType) => void;
+    handleCloseChartTypeModal: () => void;
+    handleCloseDrawing: () => void;
+    handleTimeframeClick: () => void;
+    handleChartTypeClick: () => void;
+    handleIndicatorClick: () => void;
+    handleTradeClick: () => void;
+    handleSelectedMainChartIndicator: (selectedMainChartIndicator: MainChartIndicatorInfo) => void;
+    handleMainChartIndicatorChange: (indicator: MainChartIndicatorInfo | null) => void;
+    handleCloseIndicatorModal: () => void;
+    handleCloseTimeframeModal: () => void;
+    handleCloseTradeModal: () => void;
+    handleTradeAction: (action: string) => void;
+    handleFullscreen: () => void;
+    handleCompareClick: () => void;
+    handleReplayClick: () => void;
+    stopRealTimeDataSimulation: () => void;
+    private handleContextMenu;
+    handleLeftArrowClick: () => void;
+    handleRightArrowClick: () => void;
+    handleRefreshClick: () => void;
+    handleZoomIn: () => void;
+    handleZoomOut: () => void;
+    render(): import("react/jsx-runtime").JSX.Element;
+}
+export {};

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

@@ -0,0 +1,47 @@
+import { MouseEventParams } from 'lightweight-charts';
+import { ChartLayer } from '.';
+export declare class ChartEventManager {
+    constructor();
+    registerClickEvent(chart: any, callback: (event: MouseEventParams) => void): void;
+    registerDblClickEvent(chart: any, callback: (event: MouseEventParams) => void): void;
+    registerCrosshairMoveEvent(chartLayer: ChartLayer): void;
+    private updateCurrentOHLCByCrosshair;
+    registerVisibleTimeRangeChangeEvent(chart: any, callback: (event: {
+        from: number;
+        to: number;
+    } | null) => void): void;
+    registerVisibleLogicalRangeChangeEvent(chart: any, callback: (event: {
+        from: number;
+        to: number;
+    } | null) => void): void;
+    handleKeyDown: (chartLayer: ChartLayer, event: KeyboardEvent) => void;
+    mouseUp(chartLayer: ChartLayer, event: MouseEvent): void;
+    mouseMove(chartLayer: ChartLayer, event: MouseEvent): void;
+    mouseDown(chartLayer: ChartLayer, event: MouseEvent): void;
+    documentMouseDown(chartLayer: ChartLayer, event: MouseEvent): void;
+    documentMouseMove(chartLayer: ChartLayer, event: MouseEvent): void;
+    documentMouseUp(chartLayer: ChartLayer, event: MouseEvent): void;
+    documentMouseWheel(chartLayer: ChartLayer, event: MouseEvent): void;
+    private getMousePosition;
+    private setMouseStyle;
+    private removeCircleCursor;
+    private removeDotCursor;
+    private handleLineMarkMouseDown;
+    private updateMAValues;
+    private updateEMAValues;
+    private updateBollingerBandsValues;
+    private updateIchimokuValues;
+    private updateDonchianChannelValues;
+    private updateEnvelopeValues;
+    private updateVWAPValues;
+    private coordinateToPrice;
+    private getChartPriceRange;
+    private isChartArea;
+    private isPriceArea;
+    private isTimeArea;
+    private handleDocumentMainChartPriceAreaMouseWheel;
+    private handleDocumentMainChartTimeAreaMouseWheel;
+    private handleDocumentMainChartAreaMouseWheel;
+    private handleDocumentMainChartMouseDownMove;
+    private handleGraphStyle;
+}

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

@@ -0,0 +1,62 @@
+import { default as React } from 'react';
+import { MainChartIndicatorType, Point } from '../types';
+import { ThemeConfig } from '../Theme';
+import { MainChartIndicatorInfo, MainChartIndicatorParam } from '../Indicators/MainChart/MainChartIndicatorInfo';
+import { I18n } from '../I18n';
+export interface ChartInfoProps {
+    currentTheme: ThemeConfig;
+    title?: string;
+    currentOHLC: any;
+    mousePosition: Point | null;
+    showOHLC: boolean;
+    onToggleOHLC: () => void;
+    onOpenIndicatorsModal?: () => void;
+    indicators?: MainChartIndicatorInfo[];
+    onRemoveIndicator?: (type: MainChartIndicatorType) => void;
+    onToggleIndicator?: (type: MainChartIndicatorType) => void;
+    onEditIndicatorParams?: (id: string, newParams: MainChartIndicatorParam[]) => void;
+    visibleIndicatorTypes?: MainChartIndicatorType[];
+    onOpenIndicatorSettings?: (indicator: MainChartIndicatorInfo) => void;
+    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;
+    i18n: I18n;
+}
+interface ChartInfoState {
+    currentOHLC: any;
+    mousePosition: Point | null;
+    showOHLC: boolean;
+    visibleIndicatorsMap: Map<MainChartIndicatorType, boolean>;
+}
+export declare class ChartInfo extends React.Component<ChartInfoProps, ChartInfoState> {
+    constructor(props: ChartInfoProps);
+    componentDidMount(): void;
+    componentWillUnmount(): void;
+    componentDidUpdate(prevProps: ChartInfoProps): void;
+    private handleRemoveIndicator;
+    private handleToggleIndicator;
+    private handleEditParams;
+    renderEyeIcon: (isVisible: boolean) => import("react/jsx-runtime").JSX.Element;
+    renderIndicatorWithValues: (item: MainChartIndicatorInfo) => import("react/jsx-runtime").JSX.Element | null;
+    private getActualIndicatorValue;
+    getFilteredIndicators: () => MainChartIndicatorInfo[];
+    renderNormalIndicatorParams: (item: MainChartIndicatorInfo) => import("react/jsx-runtime").JSX.Element | null;
+    render(): import("react/jsx-runtime").JSX.Element;
+}
+export {};

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

@@ -0,0 +1,281 @@
+import { ArrowLineMark } from '../Mark/Arrow/ArrowLineMark';
+import { ThickArrowLineMark } from '../Mark/Arrow/ThickArrowLineMark';
+import { DisjointChannelMark } from '../Mark/Channel/DisjointChannelMark';
+import { EquidistantChannelMark } from '../Mark/Channel/EquidistantChannelMark';
+import { LinearRegressionChannelMark } from '../Mark/Channel/LinearRegressionChannelMark';
+import { ParallelChannelMark } from '../Mark/Channel/ParallelChannelMark';
+import { ImageMark } from '../Mark/Content/ImageMark';
+import { FibonacciArcMark } from '../Mark/Fibonacci/FibonacciArcMark';
+import { FibonacciChannelMark } from '../Mark/Fibonacci/FibonacciChannelMark';
+import { FibonacciCircleMark } from '../Mark/Fibonacci/FibonacciCircleMark';
+import { FibonacciExtensionBasePriceMark } from '../Mark/Fibonacci/FibonacciExtensionBasePriceMark';
+import { FibonacciExtensionBaseTimeMark } from '../Mark/Fibonacci/FibonacciExtensionBaseTimeMark';
+import { FibonacciFanMark } from '../Mark/Fibonacci/FibonacciFanMark';
+import { FibonacciRetracementMark } from '../Mark/Fibonacci/FibonacciRetracementMark';
+import { FibonacciSpiralMark } from '../Mark/Fibonacci/FibonacciSpiralMark';
+import { FibonacciTimeZoonMark } from '../Mark/Fibonacci/FibonacciTimeZoonMark';
+import { FibonacciWedgeMark } from '../Mark/Fibonacci/FibonacciWedgeMark';
+import { AndrewPitchforkMark } from '../Mark/Fork/AndrewPitchforkMark';
+import { EnhancedAndrewPitchforkMark } from '../Mark/Fork/EnhancedAndrewPitchforkMark';
+import { GannBoxMark } from '../Mark/Gann/GannBoxMark';
+import { GannFanMark } from '../Mark/Gann/GannFanMark';
+import { GannRectangleMark } from '../Mark/Gann/GannRectangleMark';
+import { LineSegmentMark } from '../Mark/Line/LineSegmentMark';
+import { HeatMapMark } from '../Mark/Map/HeatMapMark';
+import { ABCDMark } from '../Mark/Pattern/ABCDMark';
+import { ElliottCorrectiveMark } from '../Mark/Pattern/ElliottCorrectiveMark';
+import { ElliottDoubleCombinationMark } from '../Mark/Pattern/ElliottDoubleCombinationMark';
+import { ElliottImpulseMark } from '../Mark/Pattern/ElliottImpulseMark';
+import { ElliottTriangleMark } from '../Mark/Pattern/ElliottTriangleMark';
+import { ElliottTripleCombinationMark } from '../Mark/Pattern/ElliottTripleCombinationMark';
+import { HeadAndShouldersMark } from '../Mark/Pattern/HeadAndShouldersMark';
+import { TriangleABCDMark } from '../Mark/Pattern/TriangleABCDMark';
+import { XABCDMark } from '../Mark/Pattern/XABCDMark';
+import { BrushMark } from '../Mark/Pen/BrushMark';
+import { MarkerPenMark } from '../Mark/Pen/MarkerPenMark';
+import { PencilMark } from '../Mark/Pen/PencilMark';
+import { PenMark } from '../Mark/Pen/PenMark';
+import { PriceRangeMark } from '../Mark/Range/PriceRangeMark';
+import { TimePriceRangeMark } from '../Mark/Range/TimePriceRangeMark';
+import { TimeRangeMark } from '../Mark/Range/TimeRangeMark';
+import { CircleMark } from '../Mark/Shape/CircleMark';
+import { CurveMark } from '../Mark/Shape/CurveMark';
+import { DoubleCurveMark } from '../Mark/Shape/DoubleCurveMark';
+import { EllipseMark } from '../Mark/Shape/EllipseMark';
+import { RectangleMark } from '../Mark/Shape/RectangleMark.ts';
+import { SectorMark } from '../Mark/Shape/SectorMark';
+import { TriangleMark } from '../Mark/Shape/TriangleMark';
+import { BubbleBoxMark } from '../Mark/Text/BubbleBoxMark';
+import { PinMark } from '../Mark/Text/PinMark';
+import { SignPostMark } from '../Mark/Text/SignPostMark';
+import { TextEditMark } from '../Mark/Text/TextEditMark';
+import { MarkType, MarkDrawing, Point } from '../types';
+export interface ChartMarkState {
+    pendingEmojiMark: string | null;
+    isTextMarkEditorOpen: boolean;
+    textMarkEditorPosition: {
+        x: number;
+        y: number;
+    };
+    textMarkEditorInitialData: {
+        text: string;
+        color: string;
+        fontSize: number;
+        isBold: boolean;
+        isItalic: boolean;
+    };
+    lineSegmentMarkStartPoint: Point | null;
+    arrowLineMarkStartPoint: Point | null;
+    parallelChannelMarkStartPoint: Point | null;
+    currentLineSegmentMark: LineSegmentMark | null;
+    currentArrowLineMark: ArrowLineMark | null;
+    currentParallelChannelMark: ParallelChannelMark | null;
+    linearRegressionChannelStartPoint: Point | null;
+    currentLinearRegressionChannel: LinearRegressionChannelMark | null;
+    equidistantChannelMarkStartPoint: Point | null;
+    currentEquidistantChannelMark: EquidistantChannelMark | null;
+    currentMarkMode: MarkType | null;
+    showGraphMarkToolBar: boolean;
+    showTableMarkToolBar: boolean;
+    showTextMarkToolBar: boolean;
+    isShowGrapTool: boolean;
+    isGraphMarkToolbarDragging: boolean;
+    markToolBarPosition: Point;
+    selectedTextEditMark: MarkDrawing | null;
+    selectedTableMark: MarkDrawing | null;
+    selectedGraphMark: MarkDrawing | null;
+    graphMarkToolbarDragStartPoint: Point | null;
+    disjointChannelMarkStartPoint: Point | null;
+    currentDisjointChannelMark: DisjointChannelMark | null;
+    andrewPitchforkHandlePoint: Point | null;
+    andrewPitchforkBaseStartPoint: Point | null;
+    currentAndrewPitchfork: AndrewPitchforkMark | null;
+    enhancedAndrewPitchforkHandlePoint: Point | null;
+    enhancedAndrewPitchforkBaseStartPoint: Point | null;
+    currentEnhancedAndrewPitchfork: EnhancedAndrewPitchforkMark | null;
+    rectangleMarkStartPoint: Point | null;
+    currentRectangleMark: RectangleMark | null;
+    circleMarkStartPoint: Point | null;
+    currentCircleMark: CircleMark | null;
+    ellipseMarkStartPoint: Point | null;
+    currentEllipseMark: EllipseMark | null;
+    triangleMarkStartPoint: Point | null;
+    currentTriangleMark: TriangleMark | null;
+    gannFanStartPoint: Point | null;
+    currentGannFan: GannFanMark | null;
+    gannBoxStartPoint: Point | null;
+    currentGannBox: GannBoxMark | null;
+    gannRectangleStartPoint: Point | null;
+    currentGannRectangle: GannRectangleMark | null;
+    fibonacciTimeZoonStartPoint: Point | null;
+    currentFibonacciTimeZoon: FibonacciTimeZoonMark | null;
+    fibonacciRetracementStartPoint: Point | null;
+    currentFibonacciRetracement: FibonacciRetracementMark | null;
+    fibonacciArcStartPoint: Point | null;
+    currentFibonacciArc: FibonacciArcMark | null;
+    fibonacciCircleCenterPoint: Point | null;
+    currentFibonacciCircle: FibonacciCircleMark | null;
+    fibonacciSpiralCenterPoint: Point | null;
+    currentFibonacciSpiral: FibonacciSpiralMark | null;
+    fibonacciWedgeCenterPoint: Point | null;
+    currentFibonacciWedge: FibonacciWedgeMark | null;
+    fibonacciWedgeDrawingStep: number;
+    fibonacciWedgePoints: Point[];
+    fibonacciFanStartPoint: Point | null;
+    currentFibonacciFan: FibonacciFanMark | null;
+    currentFibonacciChannel: FibonacciChannelMark | null;
+    isFibonacciChannelMode: boolean;
+    fibonacciChannelDrawingStep: number;
+    fibonacciExtensionBasePricePoints: Point[];
+    currentFibonacciExtensionBasePrice: FibonacciExtensionBasePriceMark | null;
+    fibonacciExtensionBaseTimePoints: Point[];
+    currentFibonacciExtensionBaseTime: FibonacciExtensionBaseTimeMark | null;
+    sectorPoints: Point[];
+    currentSector: SectorMark | null;
+    curveMarkStartPoint: Point | null;
+    currentCurveMark: CurveMark | null;
+    doubleCurveMarkStartPoint: Point | null;
+    currentDoubleCurveMark: DoubleCurveMark | null;
+    xabcdPoints: Point[];
+    currentXABCDMark: XABCDMark | null;
+    headAndShouldersPoints: Point[];
+    currentHeadAndShouldersMark: HeadAndShouldersMark | null;
+    abcdPoints: Point[];
+    currentABCDMark: ABCDMark | null;
+    triangleABCDPoints: Point[];
+    currentTriangleABCDMark: TriangleABCDMark | null;
+    elliottImpulsePoints: Point[];
+    currentElliottImpulseMark: ElliottImpulseMark | null;
+    elliottCorrectivePoints: Point[];
+    currentElliottCorrectiveMark: ElliottCorrectiveMark | null;
+    elliottTrianglePoints: Point[];
+    currentElliottTriangleMark: ElliottTriangleMark | null;
+    elliottDoubleCombinationPoints: Point[];
+    currentElliottDoubleCombinationMark: ElliottDoubleCombinationMark | null;
+    elliottTripleCombinationPoints: Point[];
+    currentElliottTripleCombinationMark: ElliottTripleCombinationMark | null;
+    timeRangeMarkStartPoint: Point | null;
+    currentTimeRangeMark: TimeRangeMark | null;
+    isTimeRangeMarkMode: boolean;
+    priceRangeMarkStartPoint: Point | null;
+    currentPriceRangeMark: PriceRangeMark | null;
+    isPriceRangeMarkMode: boolean;
+    timePriceRangeMarkStartPoint: Point | null;
+    currentTimePriceRangeMark: TimePriceRangeMark | null;
+    isTimePriceRangeMarkMode: boolean;
+    isPencilMode: boolean;
+    isPencilDrawing: boolean;
+    currentPencilMark: PencilMark | null;
+    pencilPoints: Point[];
+    isPenMode: boolean;
+    isPenDrawing: boolean;
+    currentPenMark: PenMark | null;
+    penPoints: Point[];
+    isBrushMode: boolean;
+    isBrushDrawing: boolean;
+    currentBrushMark: BrushMark | null;
+    brushPoints: Point[];
+    isMarkerPenMode: boolean;
+    isMarkerPenDrawing: boolean;
+    currentMarkerPen: MarkerPenMark | null;
+    markerPenPoints: Point[];
+    isEraserMode?: boolean;
+    isErasing?: boolean;
+    eraserHoveredMark?: any;
+    thickArrowLineMarkStartPoint: Point | null;
+    currentThickArrowLineMark: ThickArrowLineMark | null;
+    isImageMarkMode: boolean;
+    imageMarkStartPoint: Point | null;
+    currentImageMark: ImageMark | null;
+    showImageModal: boolean;
+    selectedImageUrl: string;
+    isImageUploadModalOpen: boolean;
+    isLongPositionMarkMode: boolean;
+    longPositionMarkStartPoint: Point | null;
+    currentLongPositionMark: any | null;
+    longPositionDrawingPhase: 'firstPoint' | 'secondPoint' | 'none';
+    isLongPositionDragging: boolean;
+    dragTarget: any | null;
+    dragPoint: string | null;
+    adjustingMode: string | null;
+    adjustStartData: {
+        time: string;
+        price: number;
+    } | null;
+    isShortPositionMarkMode: boolean;
+    shortPositionMarkStartPoint: Point | null;
+    currentShortPositionMark: any | null;
+    shortPositionDrawingPhase: 'firstPoint' | 'secondPoint' | 'none';
+    isShortPositionDragging: boolean;
+    shortPositionDragTarget: any | null;
+    shortPositionDragPoint: string | null;
+    shortPositionAdjustingMode: string | null;
+    shortPositionAdjustStartData: {
+        time: string;
+        price: number;
+    } | null;
+    isPriceLabelMarkMode: boolean;
+    priceLabelMarkPoint: Point | null;
+    currentPriceLabelMark: any | null;
+    isPriceLabelDragging: boolean;
+    priceLabelDragTarget: any | null;
+    isFlagMarkMode: boolean;
+    flagMarkPoint: Point | null;
+    currentFlagMark: any | null;
+    isFlagDragging: boolean;
+    flagDragTarget: any | null;
+    isPriceNoteMarkMode: boolean;
+    priceNoteMarkStartPoint: Point | null;
+    currentPriceNoteMark: any | null;
+    isPriceNoteDragging: boolean;
+    priceNoteDragTarget: any | null;
+    priceNoteDragPoint: 'start' | 'end' | 'line' | null;
+    isSignpostMarkMode: boolean;
+    signpostMarkPoint: Point | null;
+    currentSignpostMark: SignPostMark | null;
+    isSignpostDragging: boolean;
+    signpostDragTarget: SignPostMark | null;
+    isEmojiMarkMode?: boolean;
+    emojiMarkStartPoint?: Point | null;
+    currentEmojiMark?: any | null;
+    isEmojiDragging?: boolean;
+    emojiDragTarget?: any | null;
+    emojiDragPoint?: 'start' | 'end' | 'line' | null;
+    isPinMarkMode: boolean;
+    pinMarkPoint: Point | null;
+    currentPinMark: PinMark | null;
+    isPinDragging: boolean;
+    pinDragTarget: PinMark | null;
+    isBubbleBoxMarkMode: boolean;
+    bubbleBoxMarkPoints: Point[] | null;
+    currentBubbleBoxMark: BubbleBoxMark | null;
+    isBubbleBoxDragging: boolean;
+    bubbleBoxDragTarget: BubbleBoxMark | null;
+    bubbleBoxDragType: 'controlPoint' | 'bubble' | 'connection' | null;
+    isTextEditMarkMode: boolean;
+    isTextEditDragging: boolean;
+    textEditDragTarget: TextEditMark | null;
+    isMockKLineMarkMode: boolean;
+    mockKLineMarkStartPoint: Point | null;
+    currentMockKLineMark: any;
+    isMockKLineDragging: boolean;
+    mockKLineDragTarget: any;
+    mockKLineDragPoint: 'start' | 'end' | 'line' | null;
+    isHeatMapMode?: boolean;
+    heatMapStartPoint?: Point | null;
+    currentHeatMap?: HeatMapMark | null;
+    isHeatMapDragging?: boolean;
+    heatMapDragTarget?: HeatMapMark | null;
+    heatMapDragPoint?: 'start' | 'end' | 'body' | null;
+    heatMapDrawingPhase?: 'firstPoint' | 'secondPoint' | 'none';
+    heatMapAdjustingMode?: 'start' | 'end' | 'body' | null;
+    schiffPitchforkHandlePoint: Point | null;
+    schiffPitchforkBaseStartPoint: Point | null;
+    currentSchiffPitchfork: any | null;
+    isSchiffPitchforkMode: boolean;
+    isSchiffPitchforkDragging: boolean;
+    schiffPitchforkDragTarget: any | null;
+    schiffPitchforkDragPoint: 'handle' | 'baseStart' | 'baseEnd' | 'line' | null;
+    schiffPitchforkDrawingPhase: 'handle' | 'baseStart' | 'baseEnd' | 'none';
+    schiffPitchforkAdjustingMode: 'handle' | 'baseStart' | 'baseEnd' | null;
+}

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

@@ -0,0 +1,11 @@
+import { ThemeConfig } from '../Theme';
+import { ChartSeries } from './ChartTypeManager';
+export declare class ChartManager {
+    private chart;
+    private series;
+    private locale;
+    constructor(container: string | HTMLElement, width: number, height: number, theme: ThemeConfig, locale?: 'en' | 'zh-cn');
+    getChart(): any;
+    getSeries(): ChartSeries | null;
+    getLocale(): 'en' | 'zh-cn';
+}