candleview 1.0.5 → 1.0.6

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

@@ -1,56 +0,0 @@
-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

@@ -1,71 +0,0 @@
-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

@@ -1,71 +0,0 @@
-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

@@ -1,76 +0,0 @@
-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

@@ -1,53 +0,0 @@
-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

@@ -1,53 +0,0 @@
-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

@@ -1,56 +0,0 @@
-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

@@ -1,52 +0,0 @@
-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

@@ -1,56 +0,0 @@
-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

@@ -1,52 +0,0 @@
-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

@@ -1,52 +0,0 @@
-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;
-}