candleview 1.0.3 → 1.0.5

package/dist/components/CandleView/MarkManager/Fibonacci/FibonacciWedgeMarkManager.d.ts

@@ -0,0 +1,56 @@
+import { ChartSeries } from '../../ChartLayer/ChartTypeManager';
+import { FibonacciWedgeMark } from '../../Mark/Fibonacci/FibonacciWedgeMark';
+import { IMarkManager } from '../../Mark/IMarkManager';
+import { Point } from '../../types';
+export interface FibonacciWedgeMarkManagerProps {
+    chartSeries: ChartSeries | null;
+    chart: any;
+    containerRef: React.RefObject<HTMLDivElement | null>;
+    onCloseDrawing?: () => void;
+}
+export interface FibonacciWedgeMarkState {
+    isFibonacciWedgeMode: boolean;
+    fibonacciWedgePoints: Point[];
+    currentFibonacciWedge: FibonacciWedgeMark | null;
+    isDragging: boolean;
+    dragTarget: FibonacciWedgeMark | null;
+    dragPoint: 'center' | 'radius' | 'angle' | 'wedge' | null;
+}
+export declare class FibonacciWedgeMarkManager implements IMarkManager<FibonacciWedgeMark> {
+    private props;
+    private state;
+    private previewFibonacciWedgeMark;
+    private fibonacciWedgeMarks;
+    private dragStartData;
+    private isOperating;
+    constructor(props: FibonacciWedgeMarkManagerProps);
+    clearState(): void;
+    getMarkAtPoint(point: Point): FibonacciWedgeMark | null;
+    getCurrentDragTarget(): FibonacciWedgeMark | null;
+    getCurrentDragPoint(): string | null;
+    getCurrentOperatingMark(): FibonacciWedgeMark | null;
+    getAllMarks(): FibonacciWedgeMark[];
+    cancelOperationMode(): FibonacciWedgeMarkState;
+    setFibonacciWedgeMode: () => FibonacciWedgeMarkState;
+    cancelFibonacciWedgeMode: () => FibonacciWedgeMarkState;
+    handleMouseDown: (point: Point) => FibonacciWedgeMarkState;
+    private coordinateToPriceFallback;
+    private priceToCoordinateFallback;
+    handleMouseMove: (point: Point) => void;
+    private isPointInsideWedge;
+    private isPointNearLine;
+    private distanceToLine;
+    handleMouseUp: (point: Point) => FibonacciWedgeMarkState;
+    handleKeyDown: (event: KeyboardEvent) => FibonacciWedgeMarkState;
+    getState(): FibonacciWedgeMarkState;
+    updateProps(newProps: Partial<FibonacciWedgeMarkManagerProps>): void;
+    destroy(): void;
+    getFibonacciWedgeMarks(): FibonacciWedgeMark[];
+    removeFibonacciWedgeMark(mark: FibonacciWedgeMark): void;
+    isOperatingOnChart(): boolean;
+    private hiddenMarks;
+    hideAllMarks(): void;
+    showAllMarks(): void;
+    hideMark(mark: FibonacciWedgeMark): void;
+    showMark(mark: FibonacciWedgeMark): void;
+}

package/dist/components/CandleView/MarkManager/Fork/AndrewPitchforkMarkManager.d.ts

@@ -0,0 +1,71 @@
+import { ChartSeries } from '../../ChartLayer/ChartTypeManager';
+import { AndrewPitchforkMark } from '../../Mark/Fork/AndrewPitchforkMark';
+import { IMarkManager } from '../../Mark/IMarkManager';
+import { Point } from '../../types';
+export interface AndrewPitchforkMarkManagerProps {
+    chartSeries: ChartSeries | null;
+    chart: any;
+    containerRef: React.RefObject<HTMLDivElement | null>;
+    onCloseDrawing?: () => void;
+}
+export interface AndrewPitchforkMarkState {
+    isAndrewPitchforkMode: boolean;
+    andrewPitchforkHandlePoint: Point | null;
+    andrewPitchforkBaseStartPoint: Point | null;
+    currentAndrewPitchfork: AndrewPitchforkMark | null;
+    isDragging: boolean;
+    dragTarget: AndrewPitchforkMark | null;
+    dragPoint: 'handle' | 'baseStart' | 'baseEnd' | 'line' | null;
+    drawingPhase: 'handle' | 'baseStart' | 'baseEnd' | 'none';
+    adjustingMode: 'handle' | 'baseStart' | 'baseEnd' | null;
+    adjustStartData: {
+        handleTime: number;
+        handlePrice: number;
+        baseStartTime: number;
+        baseStartPrice: number;
+        baseEndTime: number;
+        baseEndPrice: number;
+    } | null;
+}
+export declare class AndrewPitchforkMarkManager implements IMarkManager<AndrewPitchforkMark> {
+    private props;
+    private state;
+    private previewAndrewPitchfork;
+    private andrewPitchforkMarks;
+    private dragStartData;
+    private isOperating;
+    private handleTime;
+    private handlePrice;
+    private baseStartTime;
+    private baseStartPrice;
+    private baseEndTime;
+    private baseEndPrice;
+    constructor(props: AndrewPitchforkMarkManagerProps);
+    clearState(): void;
+    getMarkAtPoint(point: Point): AndrewPitchforkMark | null;
+    getCurrentDragTarget(): AndrewPitchforkMark | null;
+    getCurrentDragPoint(): string | null;
+    getCurrentOperatingMark(): AndrewPitchforkMark | null;
+    getAllMarks(): AndrewPitchforkMark[];
+    cancelOperationMode(): AndrewPitchforkMarkState;
+    setAndrewPitchforkMode: () => AndrewPitchforkMarkState;
+    cancelAndrewPitchforkMode: () => AndrewPitchforkMarkState;
+    handleMouseDown: (point: Point) => AndrewPitchforkMarkState;
+    private handleDrawingPhaseMouseDown;
+    private isPointNearLine;
+    private pointToLineDistance;
+    handleMouseMove: (point: Point) => void;
+    handleMouseUp: (point: Point) => AndrewPitchforkMarkState;
+    handleKeyDown: (event: KeyboardEvent) => AndrewPitchforkMarkState;
+    getState(): AndrewPitchforkMarkState;
+    updateProps(newProps: Partial<AndrewPitchforkMarkManagerProps>): void;
+    destroy(): void;
+    getAndrewPitchforkMarks(): AndrewPitchforkMark[];
+    removeAndrewPitchforkMark(mark: AndrewPitchforkMark): void;
+    isOperatingOnChart(): boolean;
+    private hiddenMarks;
+    hideAllMarks(): void;
+    showAllMarks(): void;
+    hideMark(mark: AndrewPitchforkMark): void;
+    showMark(mark: AndrewPitchforkMark): void;
+}

package/dist/components/CandleView/MarkManager/Fork/EnhancedAndrewPitchforkMarkManager.d.ts

@@ -0,0 +1,71 @@
+import { ChartSeries } from '../../ChartLayer/ChartTypeManager';
+import { EnhancedAndrewPitchforkMark } from '../../Mark/Fork/EnhancedAndrewPitchforkMark';
+import { IMarkManager } from '../../Mark/IMarkManager';
+import { Point } from '../../types';
+export interface EnhancedAndrewPitchforkMarkManagerProps {
+    chartSeries: ChartSeries | null;
+    chart: any;
+    containerRef: React.RefObject<HTMLDivElement | null>;
+    onCloseDrawing?: () => void;
+}
+export interface EnhancedAndrewPitchforkMarkState {
+    isEnhancedAndrewPitchforkMode: boolean;
+    enhancedAndrewPitchforkHandlePoint: Point | null;
+    enhancedAndrewPitchforkBaseStartPoint: Point | null;
+    currentEnhancedAndrewPitchfork: EnhancedAndrewPitchforkMark | null;
+    isDragging: boolean;
+    dragTarget: EnhancedAndrewPitchforkMark | null;
+    dragPoint: 'handle' | 'baseStart' | 'baseEnd' | 'line' | null;
+    drawingPhase: 'handle' | 'baseStart' | 'baseEnd' | 'none';
+    adjustingMode: 'handle' | 'baseStart' | 'baseEnd' | null;
+    adjustStartData: {
+        handleTime: number;
+        handlePrice: number;
+        baseStartTime: number;
+        baseStartPrice: number;
+        baseEndTime: number;
+        baseEndPrice: number;
+    } | null;
+}
+export declare class EnhancedAndrewPitchforkMarkManager implements IMarkManager<EnhancedAndrewPitchforkMark> {
+    private props;
+    private state;
+    private previewEnhancedAndrewPitchfork;
+    private enhancedAndrewPitchforkMarks;
+    private dragStartData;
+    private isOperating;
+    private handleTime;
+    private handlePrice;
+    private baseStartTime;
+    private baseStartPrice;
+    private baseEndTime;
+    private baseEndPrice;
+    constructor(props: EnhancedAndrewPitchforkMarkManagerProps);
+    clearState(): void;
+    getMarkAtPoint(point: Point): EnhancedAndrewPitchforkMark | null;
+    getCurrentDragTarget(): EnhancedAndrewPitchforkMark | null;
+    getCurrentDragPoint(): string | null;
+    getCurrentOperatingMark(): EnhancedAndrewPitchforkMark | null;
+    getAllMarks(): EnhancedAndrewPitchforkMark[];
+    cancelOperationMode(): EnhancedAndrewPitchforkMarkState;
+    setEnhancedAndrewPitchforkMode: () => EnhancedAndrewPitchforkMarkState;
+    cancelEnhancedAndrewPitchforkMode: () => EnhancedAndrewPitchforkMarkState;
+    handleMouseDown: (point: Point) => EnhancedAndrewPitchforkMarkState;
+    private handleDrawingPhaseMouseDown;
+    private isPointNearLine;
+    private pointToLineDistance;
+    handleMouseMove: (point: Point) => void;
+    handleMouseUp: (point: Point) => EnhancedAndrewPitchforkMarkState;
+    handleKeyDown: (event: KeyboardEvent) => EnhancedAndrewPitchforkMarkState;
+    getState(): EnhancedAndrewPitchforkMarkState;
+    updateProps(newProps: Partial<EnhancedAndrewPitchforkMarkManagerProps>): void;
+    destroy(): void;
+    getEnhancedAndrewPitchforkMarks(): EnhancedAndrewPitchforkMark[];
+    removeEnhancedAndrewPitchforkMark(mark: EnhancedAndrewPitchforkMark): void;
+    isOperatingOnChart(): boolean;
+    private hiddenMarks;
+    hideAllMarks(): void;
+    showAllMarks(): void;
+    hideMark(mark: EnhancedAndrewPitchforkMark): void;
+    showMark(mark: EnhancedAndrewPitchforkMark): void;
+}

package/dist/components/CandleView/MarkManager/Fork/SchiffPitchforkMarkManager.d.ts

@@ -0,0 +1,76 @@
+import { ChartSeries } from '../../ChartLayer/ChartTypeManager';
+import { SchiffPitchforkMark } from '../../Mark/Fork/SchiffPitchforkMark';
+import { IMarkManager } from '../../Mark/IMarkManager';
+import { Point } from '../../types';
+export interface SchiffPitchforkMarkManagerProps {
+    chartSeries: ChartSeries | null;
+    chart: any;
+    containerRef: React.RefObject<HTMLDivElement | null>;
+    onCloseDrawing?: () => void;
+}
+export interface SchiffPitchforkMarkState {
+    isSchiffPitchforkMode: boolean;
+    schiffPitchforkHandlePoint: Point | null;
+    schiffPitchforkBaseStartPoint: Point | null;
+    schiffPitchforkExtensionPoint: Point | null;
+    currentSchiffPitchfork: SchiffPitchforkMark | null;
+    isDragging: boolean;
+    dragTarget: SchiffPitchforkMark | null;
+    dragPoint: 'handle' | 'baseStart' | 'baseEnd' | 'extension' | 'line' | null;
+    drawingPhase: 'handle' | 'baseStart' | 'baseEnd' | 'extension' | 'none';
+    adjustingMode: 'handle' | 'baseStart' | 'baseEnd' | 'extension' | null;
+    adjustStartData: {
+        handleTime: number;
+        handlePrice: number;
+        baseStartTime: number;
+        baseStartPrice: number;
+        baseEndTime: number;
+        baseEndPrice: number;
+        extensionTime: number;
+        extensionPrice: number;
+    } | null;
+}
+export declare class SchiffPitchforkMarkManager implements IMarkManager<SchiffPitchforkMark> {
+    private props;
+    private state;
+    private previewSchiffPitchfork;
+    private schiffPitchforkMarks;
+    private dragStartData;
+    private isOperating;
+    private handleTime;
+    private handlePrice;
+    private baseStartTime;
+    private baseStartPrice;
+    private baseEndTime;
+    private baseEndPrice;
+    private extensionTime;
+    private extensionPrice;
+    constructor(props: SchiffPitchforkMarkManagerProps);
+    clearState(): void;
+    getMarkAtPoint(point: Point): SchiffPitchforkMark | null;
+    getCurrentDragTarget(): SchiffPitchforkMark | null;
+    getCurrentDragPoint(): string | null;
+    getCurrentOperatingMark(): SchiffPitchforkMark | null;
+    getAllMarks(): SchiffPitchforkMark[];
+    cancelOperationMode(): SchiffPitchforkMarkState;
+    setSchiffPitchforkMode: () => SchiffPitchforkMarkState;
+    cancelSchiffPitchforkMode: () => SchiffPitchforkMarkState;
+    handleMouseDown: (point: Point) => SchiffPitchforkMarkState;
+    private handleDrawingPhaseMouseDown;
+    private isPointNearLine;
+    private pointToLineDistance;
+    handleMouseMove: (point: Point) => void;
+    handleMouseUp: (point: Point) => SchiffPitchforkMarkState;
+    handleKeyDown: (event: KeyboardEvent) => SchiffPitchforkMarkState;
+    getState(): SchiffPitchforkMarkState;
+    updateProps(newProps: Partial<SchiffPitchforkMarkManagerProps>): void;
+    destroy(): void;
+    getSchiffPitchforkMarks(): SchiffPitchforkMark[];
+    removeSchiffPitchforkMark(mark: SchiffPitchforkMark): void;
+    isOperatingOnChart(): boolean;
+    private hiddenMarks;
+    hideAllMarks(): void;
+    showAllMarks(): void;
+    hideMark(mark: SchiffPitchforkMark): void;
+    showMark(mark: SchiffPitchforkMark): void;
+}

package/dist/components/CandleView/MarkManager/Gann/GannBoxMarkManager.d.ts

@@ -0,0 +1,53 @@
+import { ChartSeries } from '../../ChartLayer/ChartTypeManager';
+import { GannBoxMark } from '../../Mark/Gann/GannBoxMark';
+import { IMarkManager } from '../../Mark/IMarkManager';
+import { Point } from '../../types';
+export interface GannBoxMarkManagerProps {
+    chartSeries: ChartSeries | null;
+    chart: any;
+    containerRef: React.RefObject<HTMLDivElement | null>;
+    onCloseDrawing?: () => void;
+}
+export interface GannBoxMarkState {
+    isGannBoxMode: boolean;
+    gannBoxStartPoint: Point | null;
+    currentGannBox: GannBoxMark | null;
+    isDragging: boolean;
+    dragTarget: GannBoxMark | null;
+    dragPoint: 'topLeft' | 'topRight' | 'bottomLeft' | 'bottomRight' | 'box' | null;
+    isDrawing: boolean;
+}
+export declare class GannBoxMarkManager implements IMarkManager<GannBoxMark> {
+    private props;
+    private state;
+    private previewGannBox;
+    private gannBoxes;
+    private isOperating;
+    private dragStartData;
+    constructor(props: GannBoxMarkManagerProps);
+    clearState(): void;
+    getMarkAtPoint(point: Point): GannBoxMark | null;
+    getCurrentDragTarget(): GannBoxMark | null;
+    getCurrentDragPoint(): string | null;
+    getCurrentOperatingMark(): GannBoxMark | null;
+    getAllMarks(): GannBoxMark[];
+    cancelOperationMode(): GannBoxMarkState;
+    setGannBoxMode: () => GannBoxMarkState;
+    cancelGannBoxMode: () => GannBoxMarkState;
+    private getValidTimeFromCoordinate;
+    handleMouseDown: (point: Point) => GannBoxMarkState;
+    handleMouseMove: (point: Point) => void;
+    handleMouseUp: (point: Point) => GannBoxMarkState;
+    handleKeyDown: (event: KeyboardEvent) => GannBoxMarkState;
+    getState(): GannBoxMarkState;
+    updateProps(newProps: Partial<GannBoxMarkManagerProps>): void;
+    destroy(): void;
+    getGannBoxes(): GannBoxMark[];
+    removeGannBox(mark: GannBoxMark): void;
+    isOperatingOnChart(): boolean;
+    private hiddenMarks;
+    hideAllMarks(): void;
+    showAllMarks(): void;
+    hideMark(mark: GannBoxMark): void;
+    showMark(mark: GannBoxMark): void;
+}

package/dist/components/CandleView/MarkManager/Gann/GannFanMarkManager.d.ts

@@ -0,0 +1,53 @@
+import { ChartSeries } from '../../ChartLayer/ChartTypeManager';
+import { GannFanMark } from '../../Mark/Gann/GannFanMark';
+import { IMarkManager } from '../../Mark/IMarkManager';
+import { Point } from '../../types';
+export interface GannFanMarkManagerProps {
+    chartSeries: ChartSeries | null;
+    chart: any;
+    containerRef: React.RefObject<HTMLDivElement | null>;
+    onCloseDrawing?: () => void;
+}
+export interface GannFanMarkState {
+    isGannFanMode: boolean;
+    gannFanStartPoint: Point | null;
+    currentGannFan: GannFanMark | null;
+    isDragging: boolean;
+    dragTarget: GannFanMark | null;
+    dragPoint: 'start' | 'center' | 'fan' | null;
+    isDrawing: boolean;
+}
+export declare class GannFanMarkManager implements IMarkManager<GannFanMark> {
+    private props;
+    private state;
+    private previewGannFan;
+    private gannFans;
+    private isOperating;
+    private dragStartData;
+    constructor(props: GannFanMarkManagerProps);
+    clearState(): void;
+    getMarkAtPoint(point: Point): GannFanMark | null;
+    getCurrentDragTarget(): GannFanMark | null;
+    getCurrentDragPoint(): string | null;
+    getCurrentOperatingMark(): GannFanMark | null;
+    getAllMarks(): GannFanMark[];
+    cancelOperationMode(): GannFanMarkState;
+    setGannFanMode: () => GannFanMarkState;
+    cancelGannFanMode: () => GannFanMarkState;
+    private getValidTimeFromCoordinate;
+    handleMouseDown: (point: Point) => GannFanMarkState;
+    handleMouseMove: (point: Point) => void;
+    handleMouseUp: (point: Point) => GannFanMarkState;
+    handleKeyDown: (event: KeyboardEvent) => GannFanMarkState;
+    getState(): GannFanMarkState;
+    updateProps(newProps: Partial<GannFanMarkManagerProps>): void;
+    destroy(): void;
+    getGannFans(): GannFanMark[];
+    removeGannFan(mark: GannFanMark): void;
+    isOperatingOnChart(): boolean;
+    private hiddenMarks;
+    hideAllMarks(): void;
+    showAllMarks(): void;
+    hideMark(mark: GannFanMark): void;
+    showMark(mark: GannFanMark): void;
+}

package/dist/components/CandleView/MarkManager/Gann/GannRectangleManager.d.ts

@@ -0,0 +1,56 @@
+import { ChartSeries } from '../../ChartLayer/ChartTypeManager';
+import { GannRectangleMark } from '../../Mark/Gann/GannRectangleMark';
+import { IMarkManager } from '../../Mark/IMarkManager';
+import { Point } from '../../types';
+export interface GannRectangleMarkManagerProps {
+    chartSeries: ChartSeries | null;
+    chart: any;
+    containerRef: React.RefObject<HTMLDivElement | null>;
+    onCloseDrawing?: () => void;
+}
+export interface GannRectangleMarkState {
+    gannRectangleStartPoint: Point | null;
+    currentGannRectangle: GannRectangleMark | null;
+    isDragging: boolean;
+    dragTarget: GannRectangleMark | null;
+    dragPoint: 'topLeft' | 'topRight' | 'bottomLeft' | 'bottomRight' | 'box' | null;
+    isDrawing: boolean;
+}
+export declare class GannRectangleMarkManager implements IMarkManager<GannRectangleMark> {
+    private props;
+    private state;
+    private previewGannRectang;
+    private gannBoxFans;
+    private isOperating;
+    private dragStartData;
+    constructor(props: GannRectangleMarkManagerProps);
+    clearState(): void;
+    getMarkAtPoint(point: Point): GannRectangleMark | null;
+    getCurrentDragTarget(): GannRectangleMark | null;
+    getCurrentDragPoint(): string | null;
+    getCurrentOperatingMark(): GannRectangleMark | null;
+    getAllMarks(): GannRectangleMark[];
+    cancelOperationMode(): GannRectangleMarkState;
+    setGannRectangMode: () => GannRectangleMarkState;
+    cancelGannRectangMode: () => GannRectangleMarkState;
+    private getValidTimeFromCoordinate;
+    handleMouseDown: (point: Point) => GannRectangleMarkState;
+    handleMouseMove: (point: Point) => void;
+    handleMouseUp: (point: Point) => GannRectangleMarkState;
+    handleKeyDown: (event: KeyboardEvent) => GannRectangleMarkState;
+    getState(): GannRectangleMarkState;
+    updateProps(newProps: Partial<GannRectangleMarkManagerProps>): void;
+    destroy(): void;
+    getGannRectangles(): GannRectangleMark[];
+    removeGannRectangle(mark: GannRectangleMark): void;
+    isOperatingOnChart(): boolean;
+    updateMarkStyles(mark: GannRectangleMark, styles: any): void;
+    getMarkStyles(mark: GannRectangleMark): Record<string, any>;
+    clearAllMarks(): void;
+    setAllMarksVisible(visible: boolean): void;
+    private hiddenMarks;
+    hideAllMarks(): void;
+    showAllMarks(): void;
+    hideMark(mark: GannRectangleMark): void;
+    showMark(mark: GannRectangleMark): void;
+}

package/dist/components/CandleView/MarkManager/Line/ArrowLineMarkManager.d.ts

@@ -0,0 +1,52 @@
+import { ChartSeries } from '../../ChartLayer/ChartTypeManager';
+import { ArrowLineMark } from '../../Mark/Arrow/ArrowLineMark';
+import { IMarkManager } from '../../Mark/IMarkManager';
+import { Point } from '../../types';
+export interface ArrowLineMarkManagerProps {
+    chartSeries: ChartSeries | null;
+    chart: any;
+    containerRef: React.RefObject<HTMLDivElement | null>;
+    onCloseDrawing?: () => void;
+}
+export interface ArrowLineMarkState {
+    isArrowLineMarkMode: boolean;
+    arrowLineMarkStartPoint: Point | null;
+    currentArrowLineMark: ArrowLineMark | null;
+    isDragging: boolean;
+    dragTarget: ArrowLineMark | null;
+    dragPoint: 'start' | 'end' | 'line' | null;
+}
+export declare class ArrowLineMarkManager implements IMarkManager<ArrowLineMark> {
+    private props;
+    private state;
+    private previewArrowLineMark;
+    private arrowLineMarks;
+    private dragStartData;
+    private isOperating;
+    constructor(props: ArrowLineMarkManagerProps);
+    clearState(): void;
+    getMarkAtPoint(point: Point): ArrowLineMark | null;
+    getCurrentDragTarget(): ArrowLineMark | null;
+    getCurrentDragPoint(): string | null;
+    getCurrentOperatingMark(): ArrowLineMark | null;
+    getAllMarks(): ArrowLineMark[];
+    cancelOperationMode(): ArrowLineMarkState;
+    setArrowLineMarkMode: () => ArrowLineMarkState;
+    cancelArrowLineMarkMode: () => ArrowLineMarkState;
+    handleMouseDown: (point: Point) => ArrowLineMarkState;
+    private isPointNearLine;
+    handleMouseMove: (point: Point) => void;
+    handleMouseUp: (point: Point) => ArrowLineMarkState;
+    handleKeyDown: (event: KeyboardEvent) => ArrowLineMarkState;
+    getState(): ArrowLineMarkState;
+    updateProps(newProps: Partial<ArrowLineMarkManagerProps>): void;
+    destroy(): void;
+    getArrowLineMarks(): ArrowLineMark[];
+    removeArrowLineMark(mark: ArrowLineMark): void;
+    isOperatingOnChart(): boolean;
+    private hiddenMarks;
+    hideAllMarks(): void;
+    showAllMarks(): void;
+    hideMark(mark: ArrowLineMark): void;
+    showMark(mark: ArrowLineMark): void;
+}

package/dist/components/CandleView/MarkManager/Line/AxisLineMarkManager.d.ts

@@ -0,0 +1,56 @@
+import { ChartSeries } from '../../ChartLayer/ChartTypeManager';
+import { IMarkManager } from '../../Mark/IMarkManager';
+import { HorizontalLineMark } from '../../Mark/Line/HorizontalLineMark';
+import { VerticalLineMark } from '../../Mark/Line/VerticalLineMark';
+import { Point } from '../../types';
+export interface AxisLineMarkManagerProps {
+    chartSeries: ChartSeries | null;
+    chart: any;
+    containerRef: React.RefObject<HTMLDivElement | null>;
+    onCloseDrawing?: () => void;
+}
+export interface AxisLineMarkState {
+    isHorizontalLineMode: boolean;
+    isVerticalLineMode: boolean;
+    currentHorizontalLine: HorizontalLineMark | null;
+    currentVerticalLine: VerticalLineMark | null;
+    isDragging: boolean;
+    dragTarget: HorizontalLineMark | VerticalLineMark | null;
+}
+export declare class AxisLineMarkManager implements IMarkManager<HorizontalLineMark | VerticalLineMark> {
+    private props;
+    private state;
+    private horizontalLines;
+    private verticalLines;
+    private dragStartData;
+    private isOperating;
+    constructor(props: AxisLineMarkManagerProps);
+    clearState(): void;
+    getMarkAtPoint(point: Point): HorizontalLineMark | VerticalLineMark | null;
+    getCurrentDragPoint(): string | null;
+    getCurrentDragTarget(): HorizontalLineMark | VerticalLineMark | null;
+    getCurrentOperatingMark(): HorizontalLineMark | VerticalLineMark | null;
+    getAllMarks(): (HorizontalLineMark | VerticalLineMark)[];
+    cancelOperationMode(): AxisLineMarkState;
+    setHorizontalLineMode: () => AxisLineMarkState;
+    setVerticalLineMode: () => AxisLineMarkState;
+    cancelAxisLineMode: () => AxisLineMarkState;
+    handleMouseDown: (point: Point) => AxisLineMarkState;
+    handleMouseMove: (point: Point) => void;
+    handleMouseUp: (point: Point) => AxisLineMarkState;
+    handleKeyDown: (event: KeyboardEvent) => AxisLineMarkState;
+    getState(): AxisLineMarkState;
+    updateProps(newProps: Partial<AxisLineMarkManagerProps>): void;
+    destroy(): void;
+    getHorizontalLines(): HorizontalLineMark[];
+    getVerticalLines(): VerticalLineMark[];
+    removeHorizontalLine(mark: HorizontalLineMark): void;
+    removeVerticalLine(mark: VerticalLineMark): void;
+    isOperatingOnChart(): boolean;
+    private hiddenHorizontalLines;
+    private hiddenVerticalLines;
+    hideAllMarks(): void;
+    showAllMarks(): void;
+    hideMark(mark: HorizontalLineMark | VerticalLineMark): void;
+    showMark(mark: HorizontalLineMark | VerticalLineMark): void;
+}

package/dist/components/CandleView/MarkManager/Line/LineSegmentMarkManager.d.ts

@@ -0,0 +1,52 @@
+import { ChartSeries } from '../../ChartLayer/ChartTypeManager';
+import { IMarkManager } from '../../Mark/IMarkManager';
+import { LineSegmentMark } from '../../Mark/Line/LineSegmentMark';
+import { Point } from '../../types';
+export interface LineSegmentMarkManagerProps {
+    chartSeries: ChartSeries | null;
+    chart: any;
+    containerRef: React.RefObject<HTMLDivElement | null>;
+    onCloseDrawing?: () => void;
+}
+export interface LineSegmentMarkState {
+    isLineSegmentMarkMode: boolean;
+    lineSegmentMarkStartPoint: Point | null;
+    currentLineSegmentMark: LineSegmentMark | null;
+    isDragging: boolean;
+    dragTarget: LineSegmentMark | null;
+    dragPoint: 'start' | 'end' | 'line' | null;
+}
+export declare class LineSegmentMarkManager implements IMarkManager<LineSegmentMark> {
+    private props;
+    private state;
+    private previewLineSegmentMark;
+    private lineMarks;
+    private dragStartData;
+    private isOperating;
+    constructor(props: LineSegmentMarkManagerProps);
+    clearState(): void;
+    getMarkAtPoint(point: Point): LineSegmentMark | null;
+    getCurrentDragTarget(): LineSegmentMark | null;
+    getCurrentDragPoint(): string | null;
+    getCurrentOperatingMark(): LineSegmentMark | null;
+    getAllMarks(): LineSegmentMark[];
+    cancelOperationMode(): LineSegmentMarkState;
+    setLineSegmentMarkMode: () => LineSegmentMarkState;
+    cancelLineSegmentMarkMode: () => LineSegmentMarkState;
+    handleMouseDown: (point: Point) => LineSegmentMarkState;
+    private isPointNearLine;
+    handleMouseMove: (point: Point) => void;
+    handleMouseUp: (point: Point) => LineSegmentMarkState;
+    handleKeyDown: (event: KeyboardEvent) => LineSegmentMarkState;
+    getState(): LineSegmentMarkState;
+    updateProps(newProps: Partial<LineSegmentMarkManagerProps>): void;
+    destroy(): void;
+    getLineSegmentMarks(): LineSegmentMark[];
+    removeLineSegmentMark(mark: LineSegmentMark): void;
+    isOperatingOnChart(): boolean;
+    private hiddenMarks;
+    hideAllMarks(): void;
+    showAllMarks(): void;
+    hideMark(mark: LineSegmentMark): void;
+    showMark(mark: LineSegmentMark): void;
+}

package/dist/components/CandleView/MarkManager/Line/ThickArrowLineMarkManager.d.ts

@@ -0,0 +1,52 @@
+import { ChartSeries } from '../../ChartLayer/ChartTypeManager';
+import { ThickArrowLineMark } from '../../Mark/Arrow/ThickArrowLineMark';
+import { IMarkManager } from '../../Mark/IMarkManager';
+import { Point } from '../../types';
+export interface ThickArrowLineMarkManagerProps {
+    chartSeries: ChartSeries | null;
+    chart: any;
+    containerRef: React.RefObject<HTMLDivElement | null>;
+    onCloseDrawing?: () => void;
+}
+export interface ThickArrowLineMarkState {
+    isThickArrowLineMarkMode: boolean;
+    thickArrowLineMarkStartPoint: Point | null;
+    currentThickArrowLineMark: ThickArrowLineMark | null;
+    isDragging: boolean;
+    dragTarget: ThickArrowLineMark | null;
+    dragPoint: 'start' | 'end' | 'line' | null;
+}
+export declare class ThickArrowLineMarkManager implements IMarkManager<ThickArrowLineMark> {
+    private props;
+    private state;
+    private previewThickArrowLineMark;
+    private thickArrowLineMarks;
+    private dragStartData;
+    private isOperating;
+    constructor(props: ThickArrowLineMarkManagerProps);
+    clearState(): void;
+    getMarkAtPoint(point: Point): ThickArrowLineMark | null;
+    getCurrentDragTarget(): ThickArrowLineMark | null;
+    getCurrentDragPoint(): string | null;
+    getCurrentOperatingMark(): ThickArrowLineMark | null;
+    getAllMarks(): ThickArrowLineMark[];
+    cancelOperationMode(): ThickArrowLineMarkState;
+    setThickArrowLineMarkMode: () => ThickArrowLineMarkState;
+    cancelThickArrowLineMarkMode: () => ThickArrowLineMarkState;
+    handleMouseDown: (point: Point) => ThickArrowLineMarkState;
+    private isPointNearLine;
+    handleMouseMove: (point: Point) => void;
+    handleMouseUp: (point: Point) => ThickArrowLineMarkState;
+    handleKeyDown: (event: KeyboardEvent) => ThickArrowLineMarkState;
+    getState(): ThickArrowLineMarkState;
+    updateProps(newProps: Partial<ThickArrowLineMarkManagerProps>): void;
+    destroy(): void;
+    getThickArrowLineMarks(): ThickArrowLineMark[];
+    removeThickArrowLineMark(mark: ThickArrowLineMark): void;
+    isOperatingOnChart(): boolean;
+    private hiddenMarks;
+    hideAllMarks(): void;
+    showAllMarks(): void;
+    hideMark(mark: ThickArrowLineMark): void;
+    showMark(mark: ThickArrowLineMark): void;
+}