candleview 1.0.0

package/dist/components/CandleView/Mark/Text/SignPostMark.d.ts

@@ -0,0 +1,110 @@
+import { IGraph } from "../IGraph";
+import { IMarkStyle } from "../IMarkStyle";
+import { MarkType } from "../../types";
+export declare class SignPostMark implements IGraph, IMarkStyle {
+    private _chart;
+    private _series;
+    private _time;
+    private _price;
+    private _renderer;
+    private _color;
+    private _backgroundColor;
+    private _textColor;
+    private _fontSize;
+    private _lineWidth;
+    private _text;
+    private markType;
+    private _lineLength;
+    private _isEditing;
+    private _editInput;
+    private _isSelected;
+    private _isHovered;
+    private _cursorVisible;
+    private _cursorTimer;
+    private _originalText;
+    private _isDragging;
+    private _graphColor;
+    private _graphLineStyle;
+    private _graphLineWidth;
+    private _isBold;
+    private _isItalic;
+    constructor(time: string, price: number, text?: string, color?: string, backgroundColor?: string, textColor?: string, fontSize?: number, lineWidth?: number);
+    updateLineStyle(lineStyle: "solid" | "dashed" | "dotted"): void;
+    getMarkType(): MarkType;
+    attached(param: any): void;
+    private _addEventListeners;
+    private _removeEventListeners;
+    updateAllViews(): void;
+    updatePosition(time: string, price: number): void;
+    updateText(text: string): void;
+    setPreviewMode(isPreview: boolean): void;
+    setShowLabel(show: boolean): void;
+    setDragging(dragging: boolean): void;
+    dragByPixels(deltaX: number, deltaY: number): void;
+    isPointNearLabel(x: number, y: number, threshold?: number): boolean;
+    private _isPointInBubble;
+    private _onMouseDown;
+    private _onDoubleClick;
+    private _showEditorModal;
+    private _onContextMenu;
+    private _onDocumentClick;
+    private _onKeyDown;
+    private _onInput;
+    private _onBlur;
+    private _startEditing;
+    private _startCursorBlink;
+    private _stopCursorBlink;
+    private _finishEditing;
+    private _cancelEditing;
+    private _cleanupEditing;
+    private _updateHoverStateAfterEdit;
+    private _selectSignPostMark;
+    private _deselectSignPostMark;
+    private _dispatchSignPostMarkSelected;
+    private _dispatchSignPostMarkDeselected;
+    private _dispatchSignPostMarkDeleted;
+    private _getScreenCoordinates;
+    private requestUpdate;
+    time(): string;
+    priceValue(): number;
+    paneViews(): {
+        renderer: () => any;
+    }[];
+    getTime(): string;
+    getPrice(): number;
+    getText(): string;
+    updateStyles(styles: {
+        [key: string]: any;
+    }): void;
+    getCurrentStyles(): Record<string, any>;
+    private _buildFontString;
+    private _getLineDashPattern;
+    getBounds(): {
+        x: any;
+        y: any;
+        minX: number;
+        maxX: any;
+        minY: number;
+        maxY: any;
+    } | null;
+    /**
+    * 吸附到最近的K线 - 修复时间格式处理
+    */
+    snapToNearestBar(targetTime: number): {
+        time: number;
+        price: number;
+    };
+    updateTextContent(text: string, color?: string, backgroundColor?: string, textColor?: string, fontSize?: number): void;
+    delete(): void;
+    getPosition(): {
+        time: string;
+        price: number;
+        text: string;
+        fontSize: number;
+        color: string;
+        backgroundColor: string;
+        textColor: string;
+    };
+    destroy(): void;
+    static createWithSnap(time: string, price: number, text?: string): SignPostMark;
+}

package/dist/components/CandleView/Mark/Text/TextEditMark.d.ts

@@ -0,0 +1,105 @@
+import { MarkType } from "../../types";
+import { IGraph } from "../IGraph";
+import { IMarkStyle } from "../IMarkStyle";
+export declare class TextEditMark implements IGraph, IMarkStyle {
+    private _chart;
+    private _series;
+    private _bubbleTime;
+    private _bubblePrice;
+    private _renderer;
+    private _graphColor;
+    private _color;
+    private _backgroundColor;
+    private _textColor;
+    private _fontSize;
+    private _lineWidth;
+    private _text;
+    private _isItalic;
+    private _isBold;
+    private _isDraggingBubble;
+    private markType;
+    private _isEditing;
+    private _editInput;
+    private _isSelected;
+    private _isHovered;
+    private _lastHoverState;
+    private _cursorVisible;
+    private _cursorTimer;
+    private _graphLineStyle;
+    constructor(bubbleTime: number, bubblePrice: number, text?: string, color?: string, backgroundColor?: string, textColor?: string, fontSize?: number, lineWidth?: number);
+    updateLineStyle(lineStyle: "solid" | "dashed" | "dotted"): void;
+    getMarkType(): MarkType;
+    attached(param: any): void;
+    private _addEventListeners;
+    private _removeEventListeners;
+    updateAllViews(): void;
+    updateBubblePosition(time: number, price: number): void;
+    setPreviewMode(isPreview: boolean): void;
+    setDraggingBubble(isDragging: boolean): void;
+    setShowLabel(show: boolean): void;
+    dragBubbleByPixels(deltaX: number, deltaY: number): void;
+    isPointNearBubble(x: number, y: number, threshold?: number): boolean;
+    private _isPointInBubble;
+    private _onMouseDown;
+    private _startDraggingBubble;
+    private _dispatchTextEditMarkDragStart;
+    private _onMouseMove;
+    private _onMouseUp;
+    private _updateHoverState;
+    private _onDoubleClick;
+    private _showEditorModal;
+    private _onContextMenu;
+    private _onDocumentClick;
+    private _onKeyDown;
+    private _onInput;
+    private _onBlur;
+    private _startEditing;
+    private _startCursorBlink;
+    private _stopCursorBlink;
+    private _finishEditing;
+    private _cancelEditing;
+    private _cleanupEditing;
+    private _updateHoverStateAfterEdit;
+    private _selectTextEditMark;
+    private _deselectTextEditMark;
+    private _dispatchTextEditMarkSelected;
+    private _dispatchTextEditMarkDeselected;
+    private _dispatchTextEditMarkDeleted;
+    private _getScreenCoordinates;
+    private requestUpdate;
+    bubbleTime(): number;
+    bubblePrice(): number;
+    getText(): string;
+    updateText(text: string): void;
+    updateStyles(styles: {
+        [key: string]: any;
+    }): void;
+    getCurrentStyles(): Record<string, any>;
+    private _getLineDashPattern;
+    getBounds(): {
+        bubbleX: any;
+        bubbleY: any;
+        minX: number;
+        maxX: number;
+        minY: number;
+        maxY: number;
+    } | null;
+    paneViews(): {
+        renderer: () => any;
+    }[];
+    startEditingImmediately(): void;
+    getBubbleTime(): number;
+    getBubblePrice(): number;
+    updateTextContent(text: string, color?: string, backgroundColor?: string, textColor?: string, fontSize?: number): void;
+    delete(): void;
+    getPosition(): {
+        bubbleTime: number;
+        bubblePrice: number;
+        text: string;
+        fontSize: number;
+        color: string;
+        backgroundColor: string;
+        textColor: string;
+    };
+    destroy(): void;
+}

package/dist/components/CandleView/MarkManager/Channel/DisjointChannelMarkManager.d.ts

@@ -0,0 +1,68 @@
+/// <reference types="react" />
+import { ChartSeries } from "../../ChartLayer/ChartTypeManager";
+import { DisjointChannelMark } from "../../Mark/Channel/DisjointChannelMark";
+import { IMarkManager } from "../../Mark/IMarkManager";
+import { Point } from "../../types";
+export interface DisjointChannelMarkManagerProps {
+    chartSeries: ChartSeries | null;
+    chart: any;
+    containerRef: React.RefObject<HTMLDivElement | null>;
+    onCloseDrawing?: () => void;
+}
+export interface DisjointChannelMarkState {
+    isDisjointChannelMarkMode: boolean;
+    disjointChannelMarkStartPoint: Point | null;
+    currentDisjointChannelMark: DisjointChannelMark | null;
+    isDragging: boolean;
+    dragTarget: DisjointChannelMark | null;
+    dragPoint: 'start' | 'end' | 'channel' | 'angle' | 'line' | null;
+    drawingPhase: 'firstPoint' | 'secondPoint' | 'widthAdjust' | 'none';
+    adjustingMode: 'start' | 'end' | 'channel' | 'angle' | null;
+    adjustStartData: {
+        time: number;
+        price: number;
+        channelHeight: number;
+        angle?: number;
+    } | null;
+}
+export declare class DisjointChannelMarkManager implements IMarkManager<DisjointChannelMark> {
+    private props;
+    private state;
+    private previewDisjointChannelMark;
+    private channelMarks;
+    private mouseDownPoint;
+    private dragStartData;
+    private isOperating;
+    private firstPointTime;
+    private firstPointPrice;
+    private secondPointTime;
+    private secondPointPrice;
+    private hoverPoint;
+    constructor(props: DisjointChannelMarkManagerProps);
+    clearState(): void;
+    getMarkAtPoint(point: Point): DisjointChannelMark | null;
+    getCurrentDragTarget(): DisjointChannelMark | null;
+    getCurrentDragPoint(): string | null;
+    getCurrentOperatingMark(): DisjointChannelMark | null;
+    getAllMarks(): DisjointChannelMark[];
+    cancelOperationMode(): DisjointChannelMarkState;
+    setDisjointChannelMarkMode: () => DisjointChannelMarkState;
+    cancelDisjointChannelMarkMode: () => DisjointChannelMarkState;
+    handleMouseDown: (point: Point) => DisjointChannelMarkState;
+    private handleDrawingPhaseMouseDown;
+    private isPointNearLine;
+    handleMouseMove: (point: Point) => void;
+    handleMouseUp: (point: Point) => DisjointChannelMarkState;
+    handleKeyDown: (event: KeyboardEvent) => DisjointChannelMarkState;
+    getState(): DisjointChannelMarkState;
+    updateProps(newProps: Partial<DisjointChannelMarkManagerProps>): void;
+    destroy(): void;
+    getDisjointChannelMarks(): DisjointChannelMark[];
+    removeDisjointChannelMark(mark: DisjointChannelMark): void;
+    isOperatingOnChart(): boolean;
+    private hiddenMarks;
+    hideAllMarks(): void;
+    showAllMarks(): void;
+    hideMark(mark: DisjointChannelMark): void;
+    showMark(mark: DisjointChannelMark): void;
+}

package/dist/components/CandleView/MarkManager/Channel/EquidistantChannelMarkManager.d.ts

@@ -0,0 +1,67 @@
+/// <reference types="react" />
+import { ChartSeries } from "../../ChartLayer/ChartTypeManager";
+import { EquidistantChannelMark } from "../../Mark/Channel/EquidistantChannelMark";
+import { IMarkManager } from "../../Mark/IMarkManager";
+import { Point } from "../../types";
+export interface EquidistantChannelMarkManagerProps {
+    chartSeries: ChartSeries | null;
+    chart: any;
+    containerRef: React.RefObject<HTMLDivElement | null>;
+    onCloseDrawing?: () => void;
+}
+export interface EquidistantChannelMarkState {
+    isEquidistantChannelMarkMode: boolean;
+    equidistantChannelMarkStartPoint: Point | null;
+    currentEquidistantChannelMark: EquidistantChannelMark | null;
+    isDragging: boolean;
+    dragTarget: EquidistantChannelMark | null;
+    dragPoint: 'start' | 'end' | 'channel' | 'line' | null;
+    drawingPhase: 'firstPoint' | 'secondPoint' | 'widthAdjust' | 'none';
+    adjustingMode: 'start' | 'end' | 'channel' | null;
+    adjustStartData: {
+        time: number;
+        price: number;
+        channelHeight: number;
+    } | null;
+}
+export declare class EquidistantChannelMarkManager implements IMarkManager<EquidistantChannelMark> {
+    private props;
+    private state;
+    private previewEquidistantChannelMark;
+    private channelMarks;
+    private mouseDownPoint;
+    private dragStartData;
+    private isOperating;
+    private firstPointTime;
+    private firstPointPrice;
+    private secondPointTime;
+    private secondPointPrice;
+    private hoverPoint;
+    constructor(props: EquidistantChannelMarkManagerProps);
+    clearState(): void;
+    getMarkAtPoint(point: Point): EquidistantChannelMark | null;
+    getCurrentDragTarget(): EquidistantChannelMark | null;
+    getCurrentDragPoint(): string | null;
+    getCurrentOperatingMark(): EquidistantChannelMark | null;
+    getAllMarks(): EquidistantChannelMark[];
+    cancelOperationMode(): EquidistantChannelMarkState;
+    setEquidistantChannelMarkMode: () => EquidistantChannelMarkState;
+    cancelEquidistantChannelMarkMode: () => EquidistantChannelMarkState;
+    handleMouseDown: (point: Point) => EquidistantChannelMarkState;
+    private handleDrawingPhaseMouseDown;
+    private isPointNearLine;
+    handleMouseMove: (point: Point) => void;
+    handleMouseUp: (point: Point) => EquidistantChannelMarkState;
+    handleKeyDown: (event: KeyboardEvent) => EquidistantChannelMarkState;
+    getState(): EquidistantChannelMarkState;
+    updateProps(newProps: Partial<EquidistantChannelMarkManagerProps>): void;
+    destroy(): void;
+    getEquidistantChannelMarks(): EquidistantChannelMark[];
+    removeEquidistantChannelMark(mark: EquidistantChannelMark): void;
+    isOperatingOnChart(): boolean;
+    private hiddenMarks;
+    hideAllMarks(): void;
+    showAllMarks(): void;
+    hideMark(mark: EquidistantChannelMark): void;
+    showMark(mark: EquidistantChannelMark): void;
+}

package/dist/components/CandleView/MarkManager/Channel/LinearRegressionChannelMarkManager.d.ts

@@ -0,0 +1,64 @@
+/// <reference types="react" />
+import { ChartSeries } from "../../ChartLayer/ChartTypeManager";
+import { LinearRegressionChannelMark } from "../../Mark/Channel/LinearRegressionChannelMark";
+import { IMarkManager } from "../../Mark/IMarkManager";
+import { Point } from "../../types";
+export interface LinearRegressionChannelMarkManagerProps {
+    chartSeries: ChartSeries | null;
+    chart: any;
+    containerRef: React.RefObject<HTMLDivElement | null>;
+    onCloseDrawing?: () => void;
+}
+export interface LinearRegressionChannelMarkState {
+    isLinearRegressionChannelMode: boolean;
+    linearRegressionChannelStartPoint: Point | null;
+    currentLinearRegressionChannel: LinearRegressionChannelMark | null;
+    isDragging: boolean;
+    dragTarget: LinearRegressionChannelMark | null;
+    dragPoint: 'start' | 'end' | 'channel' | 'line' | null;
+    drawingPhase: 'firstPoint' | 'secondPoint' | 'widthAdjust' | 'none';
+    adjustingMode: 'start' | 'end' | 'channel' | 'line' | null;
+    adjustStartData: {
+        time: number;
+        price: number;
+        deviation: number;
+    } | null;
+}
+export declare class LinearRegressionChannelMarkManager implements IMarkManager<LinearRegressionChannelMark> {
+    private props;
+    private state;
+    private previewLinearRegressionChannel;
+    private channelMarks;
+    private isOperating;
+    private firstPointTime;
+    private firstPointPrice;
+    private secondPointTime;
+    private secondPointPrice;
+    constructor(props: LinearRegressionChannelMarkManagerProps);
+    clearState(): void;
+    getMarkAtPoint(point: Point): LinearRegressionChannelMark | null;
+    getCurrentDragTarget(): LinearRegressionChannelMark | null;
+    getCurrentDragPoint(): string | null;
+    getCurrentOperatingMark(): LinearRegressionChannelMark | null;
+    getAllMarks(): LinearRegressionChannelMark[];
+    cancelOperationMode(): LinearRegressionChannelMarkState;
+    setLinearRegressionChannelMode: () => LinearRegressionChannelMarkState;
+    cancelLinearRegressionChannelMode: () => LinearRegressionChannelMarkState;
+    handleMouseDown: (point: Point) => LinearRegressionChannelMarkState;
+    private handleDrawingPhaseMouseDown;
+    handleMouseMove: (point: Point) => void;
+    private isPointInChannelArea;
+    handleMouseUp: (point: Point) => LinearRegressionChannelMarkState;
+    handleKeyDown: (event: KeyboardEvent) => LinearRegressionChannelMarkState;
+    getState(): LinearRegressionChannelMarkState;
+    updateProps(newProps: Partial<LinearRegressionChannelMarkManagerProps>): void;
+    destroy(): void;
+    getLinearRegressionChannelMarks(): LinearRegressionChannelMark[];
+    removeLinearRegressionChannelMark(mark: LinearRegressionChannelMark): void;
+    isOperatingOnChart(): boolean;
+    private hiddenMarks;
+    hideAllMarks(): void;
+    showAllMarks(): void;
+    hideMark(mark: LinearRegressionChannelMark): void;
+    showMark(mark: LinearRegressionChannelMark): void;
+}

package/dist/components/CandleView/MarkManager/Channel/ParallelChannelMarkManager.d.ts

@@ -0,0 +1,67 @@
+/// <reference types="react" />
+import { ChartSeries } from "../../ChartLayer/ChartTypeManager";
+import { ParallelChannelMark } from "../../Mark/Channel/ParallelChannelMark";
+import { IMarkManager } from "../../Mark/IMarkManager";
+import { Point } from "../../types";
+export interface ParallelChannelMarkManagerProps {
+    chartSeries: ChartSeries | null;
+    chart: any;
+    containerRef: React.RefObject<HTMLDivElement | null>;
+    onCloseDrawing?: () => void;
+}
+export interface ParallelChannelMarkState {
+    isParallelChannelMarkMode: boolean;
+    parallelChannelMarkStartPoint: Point | null;
+    currentParallelChannelMark: ParallelChannelMark | null;
+    isDragging: boolean;
+    dragTarget: ParallelChannelMark | null;
+    dragPoint: 'start' | 'end' | 'channel' | 'line' | null;
+    drawingPhase: 'firstPoint' | 'secondPoint' | 'widthAdjust' | 'none';
+    adjustingMode: 'start' | 'end' | 'channel' | null;
+    adjustStartData: {
+        time: number;
+        price: number;
+        channelHeight: number;
+    } | null;
+}
+export declare class ParallelChannelMarkManager implements IMarkManager<ParallelChannelMark> {
+    private props;
+    private state;
+    private previewParallelChannelMark;
+    private channelMarks;
+    private mouseDownPoint;
+    private dragStartData;
+    private isOperating;
+    private firstPointTime;
+    private firstPointPrice;
+    private secondPointTime;
+    private secondPointPrice;
+    private hoverPoint;
+    constructor(props: ParallelChannelMarkManagerProps);
+    clearState(): void;
+    getMarkAtPoint(point: Point): ParallelChannelMark | null;
+    getCurrentDragTarget(): ParallelChannelMark | null;
+    getCurrentDragPoint(): string | null;
+    getCurrentOperatingMark(): ParallelChannelMark | null;
+    getAllMarks(): ParallelChannelMark[];
+    cancelOperationMode(): ParallelChannelMarkState;
+    setParallelChannelMarkMode: () => ParallelChannelMarkState;
+    cancelParallelChannelMarkMode: () => ParallelChannelMarkState;
+    handleMouseDown: (point: Point) => ParallelChannelMarkState;
+    private handleDrawingPhaseMouseDown;
+    private isPointNearLine;
+    handleMouseMove: (point: Point) => void;
+    handleMouseUp: (point: Point) => ParallelChannelMarkState;
+    handleKeyDown: (event: KeyboardEvent) => ParallelChannelMarkState;
+    getState(): ParallelChannelMarkState;
+    updateProps(newProps: Partial<ParallelChannelMarkManagerProps>): void;
+    destroy(): void;
+    getParallelChannelMarks(): ParallelChannelMark[];
+    removeParallelChannelMark(mark: ParallelChannelMark): void;
+    isOperatingOnChart(): boolean;
+    private hiddenMarks;
+    hideAllMarks(): void;
+    showAllMarks(): void;
+    hideMark(mark: ParallelChannelMark): void;
+    showMark(mark: ParallelChannelMark): void;
+}

package/dist/components/CandleView/MarkManager/Content/ImageMarkManager.d.ts

@@ -0,0 +1,58 @@
+/// <reference types="react" />
+import { ChartSeries } from "../../ChartLayer/ChartTypeManager";
+import { ImageMark } from "../../Mark/Content/ImageMark";
+import { IMarkManager } from "../../Mark/IMarkManager";
+import { Point } from "../../types";
+export interface ImageMarkManagerProps {
+    chartSeries: ChartSeries | null;
+    chart: any;
+    containerRef: React.RefObject<HTMLDivElement | null>;
+    onCloseDrawing?: () => void;
+}
+export interface ImageMarkState {
+    isImageMarkMode: boolean;
+    imageMarkStartPoint: Point | null;
+    currentImageMark: ImageMark | null;
+    isDragging: boolean;
+    dragTarget: ImageMark | null;
+    dragPoint: 'start' | 'end' | 'line' | null;
+    showImageModal: boolean;
+    selectedImageUrl: string;
+}
+export declare class ImageMarkManager implements IMarkManager<ImageMark> {
+    private props;
+    private state;
+    private previewImageMark;
+    private imageMarks;
+    private hiddenMarks;
+    private dragStartData;
+    private isOperating;
+    constructor(props: ImageMarkManagerProps);
+    clearState(): void;
+    getMarkAtPoint(point: Point): ImageMark | null;
+    getCurrentDragTarget(): ImageMark | null;
+    getCurrentDragPoint(): string | null;
+    getCurrentOperatingMark(): ImageMark | null;
+    getAllMarks(): ImageMark[];
+    cancelOperationMode(): ImageMarkState;
+    openImageUploadModal: () => void;
+    closeImageUploadModal: () => void;
+    setSelectedImageUrl: (url: string) => void;
+    confirmImageSelection: () => void;
+    startImageMarkMode: () => ImageMarkState;
+    cancelImageMarkMode: () => ImageMarkState;
+    handleMouseDown: (point: Point) => ImageMarkState;
+    handleMouseMove: (point: Point) => void;
+    handleMouseUp: (point: Point) => ImageMarkState;
+    handleKeyDown: (event: KeyboardEvent) => ImageMarkState;
+    getState(): ImageMarkState;
+    updateProps(newProps: Partial<ImageMarkManagerProps>): void;
+    destroy(): void;
+    getImageMarks(): ImageMark[];
+    removeImageMark(mark: ImageMark): void;
+    isOperatingOnChart(): boolean;
+    hideAllMarks(): void;
+    showAllMarks(): void;
+    hideMark(mark: ImageMark): void;
+    showMark(mark: ImageMark): void;
+}

package/dist/components/CandleView/MarkManager/Elliott/ElliottCorrectiveMarkManager.d.ts

@@ -0,0 +1,54 @@
+/// <reference types="react" />
+import { ChartSeries } from "../../ChartLayer/ChartTypeManager";
+import { IMarkManager } from "../../Mark/IMarkManager";
+import { ElliottCorrectiveMark } from "../../Mark/Pattern/ElliottCorrectiveMark";
+import { Point } from "../../types";
+export interface ElliottCorrectiveMarkManagerProps {
+    chartSeries: ChartSeries | null;
+    chart: any;
+    containerRef: React.RefObject<HTMLDivElement | null>;
+    onCloseDrawing?: () => void;
+}
+export interface ElliottCorrectiveMarkState {
+    isElliottCorrectiveMode: boolean;
+    currentPoints: Point[];
+    currentElliottCorrectiveMark: ElliottCorrectiveMark | null;
+    isDragging: boolean;
+    dragTarget: ElliottCorrectiveMark | null;
+    dragPoint: number | null;
+}
+export declare class ElliottCorrectiveMarkManager implements IMarkManager<ElliottCorrectiveMark> {
+    private props;
+    private state;
+    private previewMark;
+    private elliottCorrectiveMarks;
+    private mouseDownPoint;
+    private dragStartData;
+    private isOperating;
+    private defaultColor;
+    constructor(props: ElliottCorrectiveMarkManagerProps);
+    clearState(): void;
+    getMarkAtPoint(point: Point): ElliottCorrectiveMark | null;
+    getCurrentDragTarget(): ElliottCorrectiveMark | null;
+    getCurrentDragPoint(): string | null;
+    getCurrentOperatingMark(): ElliottCorrectiveMark | null;
+    getAllMarks(): ElliottCorrectiveMark[];
+    cancelOperationMode(): ElliottCorrectiveMarkState;
+    setElliottCorrectiveMode: () => ElliottCorrectiveMarkState;
+    cancelElliottCorrectiveMode: () => ElliottCorrectiveMarkState;
+    handleMouseDown: (point: Point) => ElliottCorrectiveMarkState;
+    handleMouseMove: (point: Point) => void;
+    handleMouseUp: (point: Point) => ElliottCorrectiveMarkState;
+    handleKeyDown: (event: KeyboardEvent) => ElliottCorrectiveMarkState;
+    getState(): ElliottCorrectiveMarkState;
+    updateProps(newProps: Partial<ElliottCorrectiveMarkManagerProps>): void;
+    destroy(): void;
+    getElliottCorrectiveMarks(): ElliottCorrectiveMark[];
+    removeElliottCorrectiveMark(mark: ElliottCorrectiveMark): void;
+    isOperatingOnChart(): boolean;
+    private hiddenMarks;
+    hideAllMarks(): void;
+    showAllMarks(): void;
+    hideMark(mark: ElliottCorrectiveMark): void;
+    showMark(mark: ElliottCorrectiveMark): void;
+}

package/dist/components/CandleView/MarkManager/Elliott/ElliottDoubleCombinationMarkManager.d.ts

@@ -0,0 +1,54 @@
+/// <reference types="react" />
+import { ChartSeries } from "../../ChartLayer/ChartTypeManager";
+import { IMarkManager } from "../../Mark/IMarkManager";
+import { ElliottDoubleCombinationMark } from "../../Mark/Pattern/ElliottDoubleCombinationMark";
+import { Point } from "../../types";
+export interface ElliottDoubleCombinationMarkManagerProps {
+    chartSeries: ChartSeries | null;
+    chart: any;
+    containerRef: React.RefObject<HTMLDivElement | null>;
+    onCloseDrawing?: () => void;
+}
+export interface ElliottDoubleCombinationMarkState {
+    isElliottDoubleCombinationMode: boolean;
+    currentPoints: Point[];
+    currentElliottDoubleCombinationMark: ElliottDoubleCombinationMark | null;
+    isDragging: boolean;
+    dragTarget: ElliottDoubleCombinationMark | null;
+    dragPoint: number | null;
+}
+export declare class ElliottDoubleCombinationMarkManager implements IMarkManager<ElliottDoubleCombinationMark> {
+    private props;
+    private state;
+    private previewMark;
+    private elliottDoubleCombinationMarks;
+    private mouseDownPoint;
+    private dragStartData;
+    private isOperating;
+    private defaultColor;
+    constructor(props: ElliottDoubleCombinationMarkManagerProps);
+    clearState(): void;
+    getMarkAtPoint(point: Point): ElliottDoubleCombinationMark | null;
+    getCurrentDragTarget(): ElliottDoubleCombinationMark | null;
+    getCurrentDragPoint(): string | null;
+    getCurrentOperatingMark(): ElliottDoubleCombinationMark | null;
+    getAllMarks(): ElliottDoubleCombinationMark[];
+    cancelOperationMode(): ElliottDoubleCombinationMarkState;
+    setElliottDoubleCombinationMode: () => ElliottDoubleCombinationMarkState;
+    cancelElliottDoubleCombinationMode: () => ElliottDoubleCombinationMarkState;
+    handleMouseDown: (point: Point) => ElliottDoubleCombinationMarkState;
+    handleMouseMove: (point: Point) => void;
+    handleMouseUp: (point: Point) => ElliottDoubleCombinationMarkState;
+    handleKeyDown: (event: KeyboardEvent) => ElliottDoubleCombinationMarkState;
+    getState(): ElliottDoubleCombinationMarkState;
+    updateProps(newProps: Partial<ElliottDoubleCombinationMarkManagerProps>): void;
+    destroy(): void;
+    getElliottDoubleCombinationMarks(): ElliottDoubleCombinationMark[];
+    removeElliottDoubleCombinationMark(mark: ElliottDoubleCombinationMark): void;
+    isOperatingOnChart(): boolean;
+    private hiddenMarks;
+    hideAllMarks(): void;
+    showAllMarks(): void;
+    hideMark(mark: ElliottDoubleCombinationMark): void;
+    showMark(mark: ElliottDoubleCombinationMark): void;
+}