candleview 1.0.5 → 1.0.6

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

@@ -1,53 +0,0 @@
-import { ChartSeries } from '../../ChartLayer/ChartTypeManager';
-import { IMarkManager } from '../../Mark/IMarkManager';
-import { ElliottImpulseMark } from '../../Mark/Pattern/ElliottImpulseMark';
-import { Point } from '../../types';
-export interface ElliottImpulseMarkManagerProps {
-    chartSeries: ChartSeries | null;
-    chart: any;
-    containerRef: React.RefObject<HTMLDivElement | null>;
-    onCloseDrawing?: () => void;
-}
-export interface ElliottImpulseMarkState {
-    isElliottImpulseMode: boolean;
-    currentPoints: Point[];
-    currentElliottImpulseMark: ElliottImpulseMark | null;
-    isDragging: boolean;
-    dragTarget: ElliottImpulseMark | null;
-    dragPoint: number | null;
-}
-export declare class ElliottImpulseMarkManager implements IMarkManager<ElliottImpulseMark> {
-    private props;
-    private state;
-    private previewMark;
-    private elliottImpulseMarks;
-    private mouseDownPoint;
-    private dragStartData;
-    private isOperating;
-    private defaultColor;
-    constructor(props: ElliottImpulseMarkManagerProps);
-    clearState(): void;
-    getMarkAtPoint(point: Point): ElliottImpulseMark | null;
-    getCurrentDragTarget(): ElliottImpulseMark | null;
-    getCurrentDragPoint(): string | null;
-    getCurrentOperatingMark(): ElliottImpulseMark | null;
-    getAllMarks(): ElliottImpulseMark[];
-    cancelOperationMode(): ElliottImpulseMarkState;
-    setElliottImpulseMode: () => ElliottImpulseMarkState;
-    cancelElliottImpulseMode: () => ElliottImpulseMarkState;
-    handleMouseDown: (point: Point) => ElliottImpulseMarkState;
-    handleMouseMove: (point: Point) => void;
-    handleMouseUp: (point: Point) => ElliottImpulseMarkState;
-    handleKeyDown: (event: KeyboardEvent) => ElliottImpulseMarkState;
-    getState(): ElliottImpulseMarkState;
-    updateProps(newProps: Partial<ElliottImpulseMarkManagerProps>): void;
-    destroy(): void;
-    getElliottImpulseMarks(): ElliottImpulseMark[];
-    removeElliottImpulseMark(mark: ElliottImpulseMark): void;
-    isOperatingOnChart(): boolean;
-    private hiddenMarks;
-    hideAllMarks(): void;
-    showAllMarks(): void;
-    hideMark(mark: ElliottImpulseMark): void;
-    showMark(mark: ElliottImpulseMark): void;
-}

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

@@ -1,53 +0,0 @@
-import { ChartSeries } from '../../ChartLayer/ChartTypeManager';
-import { IMarkManager } from '../../Mark/IMarkManager';
-import { ElliottTriangleMark } from '../../Mark/Pattern/ElliottTriangleMark';
-import { Point } from '../../types';
-export interface ElliottTriangleMarkManagerProps {
-    chartSeries: ChartSeries | null;
-    chart: any;
-    containerRef: React.RefObject<HTMLDivElement | null>;
-    onCloseDrawing?: () => void;
-}
-export interface ElliottTriangleMarkState {
-    isElliottTriangleMode: boolean;
-    currentPoints: Point[];
-    currentElliottTriangleMark: ElliottTriangleMark | null;
-    isDragging: boolean;
-    dragTarget: ElliottTriangleMark | null;
-    dragPoint: number | null;
-}
-export declare class ElliottTriangleMarkManager implements IMarkManager<ElliottTriangleMark> {
-    private props;
-    private state;
-    private previewMark;
-    private elliottTriangleMarks;
-    private mouseDownPoint;
-    private dragStartData;
-    private isOperating;
-    private defaultColor;
-    constructor(props: ElliottTriangleMarkManagerProps);
-    clearState(): void;
-    getMarkAtPoint(point: Point): ElliottTriangleMark | null;
-    getCurrentDragTarget(): ElliottTriangleMark | null;
-    getCurrentDragPoint(): string | null;
-    getCurrentOperatingMark(): ElliottTriangleMark | null;
-    getAllMarks(): ElliottTriangleMark[];
-    cancelOperationMode(): ElliottTriangleMarkState;
-    setElliottTriangleMode: () => ElliottTriangleMarkState;
-    cancelElliottTriangleMode: () => ElliottTriangleMarkState;
-    handleMouseDown: (point: Point) => ElliottTriangleMarkState;
-    handleMouseMove: (point: Point) => void;
-    handleMouseUp: (point: Point) => ElliottTriangleMarkState;
-    handleKeyDown: (event: KeyboardEvent) => ElliottTriangleMarkState;
-    getState(): ElliottTriangleMarkState;
-    updateProps(newProps: Partial<ElliottTriangleMarkManagerProps>): void;
-    destroy(): void;
-    getElliottTriangleMarks(): ElliottTriangleMark[];
-    removeElliottTriangleMark(mark: ElliottTriangleMark): void;
-    isOperatingOnChart(): boolean;
-    private hiddenMarks;
-    hideAllMarks(): void;
-    showAllMarks(): void;
-    hideMark(mark: ElliottTriangleMark): void;
-    showMark(mark: ElliottTriangleMark): void;
-}

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

@@ -1,53 +0,0 @@
-import { ChartSeries } from '../../ChartLayer/ChartTypeManager';
-import { IMarkManager } from '../../Mark/IMarkManager';
-import { ElliottTripleCombinationMark } from '../../Mark/Pattern/ElliottTripleCombinationMark';
-import { Point } from '../../types';
-export interface ElliottTripleCombinationMarkManagerProps {
-    chartSeries: ChartSeries | null;
-    chart: any;
-    containerRef: React.RefObject<HTMLDivElement | null>;
-    onCloseDrawing?: () => void;
-}
-export interface ElliottTripleCombinationMarkState {
-    isElliottTripleCombinationMode: boolean;
-    currentPoints: Point[];
-    currentElliottTripleCombinationMark: ElliottTripleCombinationMark | null;
-    isDragging: boolean;
-    dragTarget: ElliottTripleCombinationMark | null;
-    dragPoint: number | null;
-}
-export declare class ElliottTripleCombinationMarkManager implements IMarkManager<ElliottTripleCombinationMark> {
-    private props;
-    private state;
-    private previewMark;
-    private ElliottTripleCombinationMarks;
-    private mouseDownPoint;
-    private dragStartData;
-    private isOperating;
-    private defaultColor;
-    constructor(props: ElliottTripleCombinationMarkManagerProps);
-    clearState(): void;
-    getMarkAtPoint(point: Point): ElliottTripleCombinationMark | null;
-    getCurrentDragTarget(): ElliottTripleCombinationMark | null;
-    getCurrentDragPoint(): string | null;
-    getCurrentOperatingMark(): ElliottTripleCombinationMark | null;
-    getAllMarks(): ElliottTripleCombinationMark[];
-    cancelOperationMode(): ElliottTripleCombinationMarkState;
-    setElliottTripleCombinationMode: () => ElliottTripleCombinationMarkState;
-    cancelElliottTripleCombinationMode: () => ElliottTripleCombinationMarkState;
-    handleMouseDown: (point: Point) => ElliottTripleCombinationMarkState;
-    handleMouseMove: (point: Point) => void;
-    handleMouseUp: (point: Point) => ElliottTripleCombinationMarkState;
-    handleKeyDown: (event: KeyboardEvent) => ElliottTripleCombinationMarkState;
-    getState(): ElliottTripleCombinationMarkState;
-    updateProps(newProps: Partial<ElliottTripleCombinationMarkManagerProps>): void;
-    destroy(): void;
-    getElliottTripleCombinationMarks(): ElliottTripleCombinationMark[];
-    removeElliottTripleCombinationMark(mark: ElliottTripleCombinationMark): void;
-    isOperatingOnChart(): boolean;
-    private hiddenMarks;
-    hideAllMarks(): void;
-    showAllMarks(): void;
-    hideMark(mark: ElliottTripleCombinationMark): void;
-    showMark(mark: ElliottTripleCombinationMark): void;
-}

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

@@ -1,53 +0,0 @@
-import { ChartSeries } from '../../ChartLayer/ChartTypeManager';
-import { FibonacciArcMark } from '../../Mark/Fibonacci/FibonacciArcMark';
-import { IMarkManager } from '../../Mark/IMarkManager';
-import { Point } from '../../types';
-export interface FibonacciArcMarkManagerProps {
-    chartSeries: ChartSeries | null;
-    chart: any;
-    containerRef: React.RefObject<HTMLDivElement | null>;
-    onCloseDrawing?: () => void;
-}
-export interface FibonacciArcMarkState {
-    isFibonacciArcMode: boolean;
-    fibonacciArcStartPoint: Point | null;
-    currentFibonacciArc: FibonacciArcMark | null;
-    isDragging: boolean;
-    dragTarget: FibonacciArcMark | null;
-    dragPoint: 'start' | 'end' | 'line' | null;
-}
-export declare class FibonacciArcMarkManager implements IMarkManager<FibonacciArcMark> {
-    private props;
-    private state;
-    private previewFibonacciArcMark;
-    private fibonacciArcMarks;
-    private dragStartData;
-    private isOperating;
-    constructor(props: FibonacciArcMarkManagerProps);
-    clearState(): void;
-    getMarkAtPoint(point: Point): FibonacciArcMark | null;
-    getCurrentDragTarget(): FibonacciArcMark | null;
-    getCurrentDragPoint(): string | null;
-    getCurrentOperatingMark(): FibonacciArcMark | null;
-    getAllMarks(): FibonacciArcMark[];
-    cancelOperationMode(): FibonacciArcMarkState;
-    setFibonacciArcMode: () => FibonacciArcMarkState;
-    cancelFibonacciArcMode: () => FibonacciArcMarkState;
-    handleMouseDown: (point: Point) => FibonacciArcMarkState;
-    private coordinateToPriceFallback;
-    private priceToCoordinateFallback;
-    handleMouseMove: (point: Point) => void;
-    handleMouseUp: (point: Point) => FibonacciArcMarkState;
-    handleKeyDown: (event: KeyboardEvent) => FibonacciArcMarkState;
-    getState(): FibonacciArcMarkState;
-    updateProps(newProps: Partial<FibonacciArcMarkManagerProps>): void;
-    destroy(): void;
-    getFibonacciArcMarks(): FibonacciArcMark[];
-    removeFibonacciArcMark(mark: FibonacciArcMark): void;
-    isOperatingOnChart(): boolean;
-    private hiddenMarks;
-    hideAllMarks(): void;
-    showAllMarks(): void;
-    hideMark(mark: FibonacciArcMark): void;
-    showMark(mark: FibonacciArcMark): void;
-}

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

@@ -1,64 +0,0 @@
-import { ChartSeries } from '../../ChartLayer/ChartTypeManager';
-import { FibonacciChannelMark } from '../../Mark/Fibonacci/FibonacciChannelMark';
-import { IMarkManager } from '../../Mark/IMarkManager';
-import { Point } from '../../types';
-export interface FibonacciChannelMarkManagerProps {
-    chartSeries: ChartSeries | null;
-    chart: any;
-    containerRef: React.RefObject<HTMLDivElement | null>;
-    onCloseDrawing?: () => void;
-}
-export interface FibonacciChannelMarkState {
-    isFibonacciChannelMarkMode: boolean;
-    fibonacciChannelMarkStartPoint: Point | null;
-    currentFibonacciChannelMark: FibonacciChannelMark | null;
-    isDragging: boolean;
-    dragTarget: FibonacciChannelMark | 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 FibonacciChannelMarkManager implements IMarkManager<FibonacciChannelMark> {
-    private props;
-    private state;
-    private previewFibonacciChannelMark;
-    private channelMarks;
-    private mouseDownPoint;
-    private isOperating;
-    private firstPointTime;
-    private firstPointPrice;
-    private secondPointTime;
-    private secondPointPrice;
-    constructor(props: FibonacciChannelMarkManagerProps);
-    clearState(): void;
-    getMarkAtPoint(point: Point): FibonacciChannelMark | null;
-    getCurrentDragTarget(): FibonacciChannelMark | null;
-    getCurrentDragPoint(): string | null;
-    getCurrentOperatingMark(): FibonacciChannelMark | null;
-    getAllMarks(): FibonacciChannelMark[];
-    cancelOperationMode(): FibonacciChannelMarkState;
-    setFibonacciChannelMarkMode: () => FibonacciChannelMarkState;
-    cancelFibonacciChannelMarkMode: () => FibonacciChannelMarkState;
-    handleMouseDown: (point: Point) => FibonacciChannelMarkState;
-    private handleDrawingPhaseMouseDown;
-    private isPointNearLine;
-    handleMouseMove: (point: Point) => void;
-    handleMouseUp: (point: Point) => FibonacciChannelMarkState;
-    handleKeyDown: (event: KeyboardEvent) => FibonacciChannelMarkState;
-    getState(): FibonacciChannelMarkState;
-    updateProps(newProps: Partial<FibonacciChannelMarkManagerProps>): void;
-    destroy(): void;
-    getFibonacciChannelMarks(): FibonacciChannelMark[];
-    removeFibonacciChannelMark(mark: FibonacciChannelMark): void;
-    isOperatingOnChart(): boolean;
-    private hiddenMarks;
-    hideAllMarks(): void;
-    showAllMarks(): void;
-    hideMark(mark: FibonacciChannelMark): void;
-    showMark(mark: FibonacciChannelMark): void;
-}

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

@@ -1,53 +0,0 @@
-import { ChartSeries } from '../../ChartLayer/ChartTypeManager';
-import { FibonacciCircleMark } from '../../Mark/Fibonacci/FibonacciCircleMark';
-import { IMarkManager } from '../../Mark/IMarkManager';
-import { Point } from '../../types';
-export interface FibonacciCircleMarkManagerProps {
-    chartSeries: ChartSeries | null;
-    chart: any;
-    containerRef: React.RefObject<HTMLDivElement | null>;
-    onCloseDrawing?: () => void;
-}
-export interface FibonacciCircleMarkState {
-    isFibonacciCircleMode: boolean;
-    fibonacciCircleCenterPoint: Point | null;
-    currentFibonacciCircle: FibonacciCircleMark | null;
-    isDragging: boolean;
-    dragTarget: FibonacciCircleMark | null;
-    dragPoint: 'center' | 'radius' | 'circle' | null;
-}
-export declare class FibonacciCircleMarkManager implements IMarkManager<FibonacciCircleMark> {
-    private props;
-    private state;
-    private previewFibonacciCircleMark;
-    private fibonacciCircleMarks;
-    private dragStartData;
-    private isOperating;
-    constructor(props: FibonacciCircleMarkManagerProps);
-    clearState(): void;
-    getMarkAtPoint(point: Point): FibonacciCircleMark | null;
-    getCurrentDragTarget(): FibonacciCircleMark | null;
-    getCurrentDragPoint(): string | null;
-    getCurrentOperatingMark(): FibonacciCircleMark | null;
-    getAllMarks(): FibonacciCircleMark[];
-    cancelOperationMode(): FibonacciCircleMarkState;
-    setFibonacciCircleMode: () => FibonacciCircleMarkState;
-    cancelFibonacciCircleMode: () => FibonacciCircleMarkState;
-    handleMouseDown: (point: Point) => FibonacciCircleMarkState;
-    private coordinateToPriceFallback;
-    private priceToCoordinateFallback;
-    handleMouseMove: (point: Point) => void;
-    handleMouseUp: (point: Point) => FibonacciCircleMarkState;
-    handleKeyDown: (event: KeyboardEvent) => FibonacciCircleMarkState;
-    getState(): FibonacciCircleMarkState;
-    updateProps(newProps: Partial<FibonacciCircleMarkManagerProps>): void;
-    destroy(): void;
-    getFibonacciCircleMarks(): FibonacciCircleMark[];
-    removeFibonacciCircleMark(mark: FibonacciCircleMark): void;
-    isOperatingOnChart(): boolean;
-    private hiddenMarks;
-    hideAllMarks(): void;
-    showAllMarks(): void;
-    hideMark(mark: FibonacciCircleMark): void;
-    showMark(mark: FibonacciCircleMark): void;
-}

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

@@ -1,54 +0,0 @@
-import { ChartSeries } from '../../ChartLayer/ChartTypeManager';
-import { FibonacciExtensionBasePriceMark } from '../../Mark/Fibonacci/FibonacciExtensionBasePriceMark';
-import { IMarkManager } from '../../Mark/IMarkManager';
-import { Point } from '../../types';
-export interface FibonacciExtensionBasePriceMarkManagerProps {
-    chartSeries: ChartSeries | null;
-    chart: any;
-    containerRef: React.RefObject<HTMLDivElement | null>;
-    onCloseDrawing?: () => void;
-}
-export interface FibonacciExtensionBasePriceMarkState {
-    isFibonacciExtensionBasePriceMode: boolean;
-    fibonacciExtensionBasePricePoints: Point[];
-    currentFibonacciExtensionBasePrice: FibonacciExtensionBasePriceMark | null;
-    isDragging: boolean;
-    dragTarget: FibonacciExtensionBasePriceMark | null;
-    dragPoint: 'start' | 'end' | 'extension' | 'line' | null;
-    drawingPhase: 'firstPoint' | 'secondPoint' | 'extensionPoint' | 'none';
-}
-export declare class FibonacciExtensionBasePriceMarkManager implements IMarkManager<FibonacciExtensionBasePriceMark> {
-    private props;
-    private state;
-    private previewFibonacciExtensionBasePriceMark;
-    private FibonacciExtensionBasePriceMarks;
-    private dragStartData;
-    private isOperating;
-    constructor(props: FibonacciExtensionBasePriceMarkManagerProps);
-    clearState(): void;
-    getMarkAtPoint(point: Point): FibonacciExtensionBasePriceMark | null;
-    getCurrentDragTarget(): FibonacciExtensionBasePriceMark | null;
-    getCurrentDragPoint(): string | null;
-    getCurrentOperatingMark(): FibonacciExtensionBasePriceMark | null;
-    getAllMarks(): FibonacciExtensionBasePriceMark[];
-    cancelOperationMode(): FibonacciExtensionBasePriceMarkState;
-    setFibonacciExtensionBasePriceMode: () => FibonacciExtensionBasePriceMarkState;
-    cancelFibonacciExtensionMode: () => FibonacciExtensionBasePriceMarkState;
-    handleMouseDown: (point: Point) => FibonacciExtensionBasePriceMarkState;
-    private coordinateToPriceFallback;
-    private priceToCoordinateFallback;
-    handleMouseMove: (point: Point) => void;
-    handleMouseUp: (point: Point) => FibonacciExtensionBasePriceMarkState;
-    handleKeyDown: (event: KeyboardEvent) => FibonacciExtensionBasePriceMarkState;
-    getState(): FibonacciExtensionBasePriceMarkState;
-    updateProps(newProps: Partial<FibonacciExtensionBasePriceMarkManagerProps>): void;
-    destroy(): void;
-    getFibonacciExtensionBasePriceMarks(): FibonacciExtensionBasePriceMark[];
-    removeFibonacciExtensionBasePriceMark(mark: FibonacciExtensionBasePriceMark): void;
-    isOperatingOnChart(): boolean;
-    private hiddenMarks;
-    hideAllMarks(): void;
-    showAllMarks(): void;
-    hideMark(mark: FibonacciExtensionBasePriceMark): void;
-    showMark(mark: FibonacciExtensionBasePriceMark): void;
-}

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

@@ -1,54 +0,0 @@
-import { ChartSeries } from '../../ChartLayer/ChartTypeManager';
-import { FibonacciExtensionBaseTimeMark } from '../../Mark/Fibonacci/FibonacciExtensionBaseTimeMark';
-import { IMarkManager } from '../../Mark/IMarkManager';
-import { Point } from '../../types';
-export interface FibonacciExtensionBaseTimeMarkManagerProps {
-    chartSeries: ChartSeries | null;
-    chart: any;
-    containerRef: React.RefObject<HTMLDivElement | null>;
-    onCloseDrawing?: () => void;
-}
-export interface FibonacciExtensionBaseTimeMarkState {
-    isFibonacciExtensionBaseTimeMode: boolean;
-    fibonacciExtensionBaseTimePoints: Point[];
-    currentFibonacciExtensionBaseTime: FibonacciExtensionBaseTimeMark | null;
-    isDragging: boolean;
-    dragTarget: FibonacciExtensionBaseTimeMark | null;
-    dragPoint: 'start' | 'end' | 'extension' | 'line' | null;
-    drawingPhase: 'firstPoint' | 'secondPoint' | 'extensionPoint' | 'none';
-}
-export declare class FibonacciExtensionBaseTimeMarkManager implements IMarkManager<FibonacciExtensionBaseTimeMark> {
-    private props;
-    private state;
-    private previewFibonacciExtensionBaseTimeMark;
-    private FibonacciExtensionBaseTimeMarks;
-    private dragStartData;
-    private isOperating;
-    constructor(props: FibonacciExtensionBaseTimeMarkManagerProps);
-    clearState(): void;
-    getMarkAtPoint(point: Point): FibonacciExtensionBaseTimeMark | null;
-    getCurrentDragTarget(): FibonacciExtensionBaseTimeMark | null;
-    getCurrentDragPoint(): string | null;
-    getCurrentOperatingMark(): FibonacciExtensionBaseTimeMark | null;
-    getAllMarks(): FibonacciExtensionBaseTimeMark[];
-    cancelOperationMode(): FibonacciExtensionBaseTimeMarkState;
-    setFibonacciExtensionBaseTimeMode: () => FibonacciExtensionBaseTimeMarkState;
-    cancelFibonacciExtensionMode: () => FibonacciExtensionBaseTimeMarkState;
-    handleMouseDown: (point: Point) => FibonacciExtensionBaseTimeMarkState;
-    private coordinateToPriceFallback;
-    private priceToCoordinateFallback;
-    handleMouseMove: (point: Point) => void;
-    handleMouseUp: (point: Point) => FibonacciExtensionBaseTimeMarkState;
-    handleKeyDown: (event: KeyboardEvent) => FibonacciExtensionBaseTimeMarkState;
-    getState(): FibonacciExtensionBaseTimeMarkState;
-    updateProps(newProps: Partial<FibonacciExtensionBaseTimeMarkManagerProps>): void;
-    destroy(): void;
-    getFibonacciExtensionBaseTimeMarks(): FibonacciExtensionBaseTimeMark[];
-    removeFibonacciExtensionBaseTimeMark(mark: FibonacciExtensionBaseTimeMark): void;
-    isOperatingOnChart(): boolean;
-    private hiddenMarks;
-    hideAllMarks(): void;
-    showAllMarks(): void;
-    hideMark(mark: FibonacciExtensionBaseTimeMark): void;
-    showMark(mark: FibonacciExtensionBaseTimeMark): void;
-}

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

@@ -1,53 +0,0 @@
-import { ChartSeries } from '../../ChartLayer/ChartTypeManager';
-import { FibonacciFanMark } from '../../Mark/Fibonacci/FibonacciFanMark';
-import { IMarkManager } from '../../Mark/IMarkManager';
-import { Point } from '../../types';
-export interface FibonacciFanMarkManagerProps {
-    chartSeries: ChartSeries | null;
-    chart: any;
-    containerRef: React.RefObject<HTMLDivElement | null>;
-    onCloseDrawing?: () => void;
-}
-export interface FibonacciFanMarkState {
-    isFibonacciFanMode: boolean;
-    fibonacciFanStartPoint: Point | null;
-    currentFibonacciFan: FibonacciFanMark | null;
-    isDragging: boolean;
-    dragTarget: FibonacciFanMark | null;
-    dragPoint: 'start' | 'center' | 'fan' | null;
-    isDrawing: boolean;
-}
-export declare class FibonacciFanMarkManager implements IMarkManager<FibonacciFanMark> {
-    private props;
-    private state;
-    private previewFibonacciFan;
-    private fibonacciFans;
-    private isOperating;
-    private dragStartData;
-    constructor(props: FibonacciFanMarkManagerProps);
-    clearState(): void;
-    getMarkAtPoint(point: Point): FibonacciFanMark | null;
-    getCurrentDragTarget(): FibonacciFanMark | null;
-    getCurrentDragPoint(): string | null;
-    getCurrentOperatingMark(): FibonacciFanMark | null;
-    getAllMarks(): FibonacciFanMark[];
-    cancelOperationMode(): FibonacciFanMarkState;
-    setFibonacciFanMode: () => FibonacciFanMarkState;
-    cancelFibonacciFanMode: () => FibonacciFanMarkState;
-    private getValidTimeFromCoordinate;
-    handleMouseDown: (point: Point) => FibonacciFanMarkState;
-    handleMouseMove: (point: Point) => void;
-    handleMouseUp: (point: Point) => FibonacciFanMarkState;
-    handleKeyDown: (event: KeyboardEvent) => FibonacciFanMarkState;
-    getState(): FibonacciFanMarkState;
-    updateProps(newProps: Partial<FibonacciFanMarkManagerProps>): void;
-    destroy(): void;
-    getFibonacciFans(): FibonacciFanMark[];
-    removeFibonacciFan(mark: FibonacciFanMark): void;
-    isOperatingOnChart(): boolean;
-    private hiddenMarks;
-    hideAllMarks(): void;
-    showAllMarks(): void;
-    hideMark(mark: FibonacciFanMark): void;
-    showMark(mark: FibonacciFanMark): void;
-}

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

@@ -1,54 +0,0 @@
-import { ChartSeries } from '../../ChartLayer/ChartTypeManager';
-import { FibonacciRetracementMark } from '../../Mark/Fibonacci/FibonacciRetracementMark';
-import { IMarkManager } from '../../Mark/IMarkManager';
-import { Point } from '../../types';
-export interface FibonacciRetracementMarkManagerProps {
-    chartSeries: ChartSeries | null;
-    chart: any;
-    containerRef: React.RefObject<HTMLDivElement | null>;
-    onCloseDrawing?: () => void;
-}
-export interface FibonacciRetracementMarkState {
-    isFibonacciRetracementMode: boolean;
-    fibonacciRetracementStartPoint: Point | null;
-    currentFibonacciRetracement: FibonacciRetracementMark | null;
-    isDragging: boolean;
-    dragTarget: FibonacciRetracementMark | null;
-    dragPoint: 'start' | 'end' | 'line' | null;
-}
-export declare class FibonacciRetracementMarkManager implements IMarkManager<FibonacciRetracementMark> {
-    private props;
-    private state;
-    private previewFibonacciRetracementMark;
-    private fibonacciRetracementMarks;
-    private dragStartData;
-    private isOperating;
-    constructor(props: FibonacciRetracementMarkManagerProps);
-    clearState(): void;
-    getMarkAtPoint(point: Point): FibonacciRetracementMark | null;
-    getCurrentDragTarget(): FibonacciRetracementMark | null;
-    getCurrentDragPoint(): string | null;
-    getCurrentOperatingMark(): FibonacciRetracementMark | null;
-    getAllMarks(): FibonacciRetracementMark[];
-    cancelOperationMode(): FibonacciRetracementMarkState;
-    setFibonacciRetracementMode: () => FibonacciRetracementMarkState;
-    cancelFibonacciRetracementMode: () => FibonacciRetracementMarkState;
-    handleMouseDown: (point: Point) => FibonacciRetracementMarkState;
-    private coordinateToPriceFallback;
-    private priceToCoordinateFallback;
-    private getPriceRange;
-    handleMouseMove: (point: Point) => void;
-    handleMouseUp: (point: Point) => FibonacciRetracementMarkState;
-    handleKeyDown: (event: KeyboardEvent) => FibonacciRetracementMarkState;
-    getState(): FibonacciRetracementMarkState;
-    updateProps(newProps: Partial<FibonacciRetracementMarkManagerProps>): void;
-    destroy(): void;
-    getFibonacciRetracementMarks(): FibonacciRetracementMark[];
-    removeFibonacciRetracementMark(mark: FibonacciRetracementMark): void;
-    isOperatingOnChart(): boolean;
-    private hiddenMarks;
-    hideAllMarks(): void;
-    showAllMarks(): void;
-    hideMark(mark: FibonacciRetracementMark): void;
-    showMark(mark: FibonacciRetracementMark): void;
-}

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

@@ -1,53 +0,0 @@
-import { ChartSeries } from '../../ChartLayer/ChartTypeManager';
-import { FibonacciSpiralMark } from '../../Mark/Fibonacci/FibonacciSpiralMark';
-import { IMarkManager } from '../../Mark/IMarkManager';
-import { Point } from '../../types';
-export interface FibonacciSpiralMarkManagerProps {
-    chartSeries: ChartSeries | null;
-    chart: any;
-    containerRef: React.RefObject<HTMLDivElement | null>;
-    onCloseDrawing?: () => void;
-}
-export interface FibonacciSpiralMarkState {
-    isFibonacciSpiralMode: boolean;
-    fibonacciSpiralCenterPoint: Point | null;
-    currentFibonacciSpiral: FibonacciSpiralMark | null;
-    isDragging: boolean;
-    dragTarget: FibonacciSpiralMark | null;
-    dragPoint: 'center' | 'radius' | 'spiral' | null;
-}
-export declare class FibonacciSpiralMarkManager implements IMarkManager<FibonacciSpiralMark> {
-    private props;
-    private state;
-    private previewFibonacciSpiralMark;
-    private fibonacciSpiralMarks;
-    private dragStartData;
-    private isOperating;
-    constructor(props: FibonacciSpiralMarkManagerProps);
-    clearState(): void;
-    getMarkAtPoint(point: Point): FibonacciSpiralMark | null;
-    getCurrentDragTarget(): FibonacciSpiralMark | null;
-    getCurrentDragPoint(): string | null;
-    getCurrentOperatingMark(): FibonacciSpiralMark | null;
-    getAllMarks(): FibonacciSpiralMark[];
-    cancelOperationMode(): FibonacciSpiralMarkState;
-    setFibonacciSpiralMode: () => FibonacciSpiralMarkState;
-    cancelFibonacciSpiralMode: () => FibonacciSpiralMarkState;
-    handleMouseDown: (point: Point) => FibonacciSpiralMarkState;
-    private coordinateToPriceFallback;
-    private priceToCoordinateFallback;
-    handleMouseMove: (point: Point) => void;
-    handleMouseUp: (point: Point) => FibonacciSpiralMarkState;
-    handleKeyDown: (event: KeyboardEvent) => FibonacciSpiralMarkState;
-    getState(): FibonacciSpiralMarkState;
-    updateProps(newProps: Partial<FibonacciSpiralMarkManagerProps>): void;
-    destroy(): void;
-    getFibonacciSpiralMarks(): FibonacciSpiralMark[];
-    removeFibonacciSpiralMark(mark: FibonacciSpiralMark): void;
-    isOperatingOnChart(): boolean;
-    private hiddenMarks;
-    hideAllMarks(): void;
-    showAllMarks(): void;
-    hideMark(mark: FibonacciSpiralMark): void;
-    showMark(mark: FibonacciSpiralMark): void;
-}

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

@@ -1,53 +0,0 @@
-import { ChartSeries } from '../../ChartLayer/ChartTypeManager';
-import { FibonacciTimeZoonMark } from '../../Mark/Fibonacci/FibonacciTimeZoonMark';
-import { IMarkManager } from '../../Mark/IMarkManager';
-import { Point } from '../../types';
-export interface FibonacciTimeZoonMarkManagerProps {
-    chartSeries: ChartSeries | null;
-    chart: any;
-    containerRef: React.RefObject<HTMLDivElement | null>;
-    onCloseDrawing?: () => void;
-}
-export interface FibonacciTimeZoonMarkState {
-    isFibonacciTimeZoneMode: boolean;
-    fibonacciTimeZoonStartPoint: Point | null;
-    currentFibonacciTimeZoon: FibonacciTimeZoonMark | null;
-    isDragging: boolean;
-    dragTarget: FibonacciTimeZoonMark | null;
-    dragPoint: 'start' | 'end' | 'line' | null;
-}
-export declare class FibonacciTimeZoonMarkManager implements IMarkManager<FibonacciTimeZoonMark> {
-    private props;
-    private state;
-    private previewFibonacciTimeZoonMark;
-    private fibonacciTimeZoneMarks;
-    private mouseDownPoint;
-    private dragStartData;
-    private isOperating;
-    constructor(props: FibonacciTimeZoonMarkManagerProps);
-    clearState(): void;
-    getMarkAtPoint(point: Point): FibonacciTimeZoonMark | null;
-    getCurrentDragTarget(): FibonacciTimeZoonMark | null;
-    getCurrentDragPoint(): string | null;
-    getCurrentOperatingMark(): FibonacciTimeZoonMark | null;
-    getAllMarks(): FibonacciTimeZoonMark[];
-    cancelOperationMode(): FibonacciTimeZoonMarkState;
-    setFibonacciTimeZoneMode: () => FibonacciTimeZoonMarkState;
-    cancelFibonacciTimeZoneMode: () => FibonacciTimeZoonMarkState;
-    handleMouseDown: (point: Point) => FibonacciTimeZoonMarkState;
-    private isPointNearVerticalLine;
-    handleMouseMove: (point: Point) => void;
-    handleMouseUp: (point: Point) => FibonacciTimeZoonMarkState;
-    handleKeyDown: (event: KeyboardEvent) => FibonacciTimeZoonMarkState;
-    getState(): FibonacciTimeZoonMarkState;
-    updateProps(newProps: Partial<FibonacciTimeZoonMarkManagerProps>): void;
-    destroy(): void;
-    getFibonacciTimeZoonMarks(): FibonacciTimeZoonMark[];
-    removeFibonacciTimeZoonMark(mark: FibonacciTimeZoonMark): void;
-    isOperatingOnChart(): boolean;
-    private hiddenMarks;
-    hideAllMarks(): void;
-    showAllMarks(): void;
-    hideMark(mark: FibonacciTimeZoonMark): void;
-    showMark(mark: FibonacciTimeZoonMark): void;
-}