candleview 1.0.5 → 1.0.6

package/dist/components/CandleView/MarkManager/Range/PriceRangeMarkManager.d.ts

@@ -1,63 +0,0 @@
-import { ChartSeries } from '../../ChartLayer/ChartTypeManager';
-import { IMarkManager } from '../../Mark/IMarkManager';
-import { PriceRangeMark } from '../../Mark/Range/PriceRangeMark';
-import { Point } from '../../types';
-export interface PriceRangeMarkManagerProps {
-    chartSeries: ChartSeries | null;
-    chart: any;
-    containerRef: React.RefObject<HTMLDivElement | null>;
-    onCloseDrawing?: () => void;
-}
-export interface PriceRangeMarkState {
-    isPriceRangeMarkMode: boolean;
-    priceRangeMarkStartPoint: Point | null;
-    currentPriceRangeMark: PriceRangeMark | null;
-    isDragging: boolean;
-    dragTarget: PriceRangeMark | null;
-    dragPoint: 'start' | 'end' | 'line' | null;
-    drawingPhase: 'firstPoint' | 'secondPoint' | 'none';
-    adjustingMode: 'start' | 'end' | null;
-    adjustStartData: {
-        time: number;
-        price: number;
-    } | null;
-}
-export declare class PriceRangeMarkManager implements IMarkManager<PriceRangeMark> {
-    private props;
-    private state;
-    private previewPriceRangeMark;
-    private priceRangeMarks;
-    private dragStartData;
-    private isOperating;
-    private firstPointPrice;
-    private firstPointTime;
-    private secondPointPrice;
-    private secondPointTime;
-    constructor(props: PriceRangeMarkManagerProps);
-    clearState(): void;
-    getMarkAtPoint(point: Point): PriceRangeMark | null;
-    getCurrentDragTarget(): PriceRangeMark | null;
-    getCurrentDragPoint(): string | null;
-    getCurrentOperatingMark(): PriceRangeMark | null;
-    getAllMarks(): PriceRangeMark[];
-    cancelOperationMode(): PriceRangeMarkState;
-    setPriceRangeMarkMode: () => PriceRangeMarkState;
-    cancelPriceRangeMarkMode: () => PriceRangeMarkState;
-    handleMouseDown: (point: Point) => PriceRangeMarkState;
-    private handleExistingMarkInteraction;
-    private completePriceRangeMark;
-    handleMouseMove: (point: Point) => void;
-    handleMouseUp: (point: Point) => PriceRangeMarkState;
-    handleKeyDown: (event: KeyboardEvent) => PriceRangeMarkState;
-    getState(): PriceRangeMarkState;
-    updateProps(newProps: Partial<PriceRangeMarkManagerProps>): void;
-    destroy(): void;
-    getPriceRangeMarks(): PriceRangeMark[];
-    removePriceRangeMark(mark: PriceRangeMark): void;
-    isOperatingOnChart(): boolean;
-    private hiddenPriceRangeMarks;
-    hideAllMarks(): void;
-    showAllMarks(): void;
-    hideMark(mark: PriceRangeMark): void;
-    showMark(mark: PriceRangeMark): void;
-}

package/dist/components/CandleView/MarkManager/Range/ShortPositionMarkManager.d.ts

@@ -1,63 +0,0 @@
-import { ChartSeries } from '../../ChartLayer/ChartTypeManager';
-import { IMarkManager } from '../../Mark/IMarkManager';
-import { ShortPositionMark } from '../../Mark/Range/ShortPositionMark';
-import { Point } from '../../types';
-export interface ShortPositionMarkManagerProps {
-    chartSeries: ChartSeries | null;
-    chart: any;
-    containerRef: React.RefObject<HTMLDivElement | null>;
-    onCloseDrawing?: () => void;
-}
-export interface ShortPositionMarkState {
-    isShortPositionMarkMode: boolean;
-    shortPositionMarkStartPoint: Point | null;
-    currentShortPositionMark: ShortPositionMark | null;
-    isDragging: boolean;
-    dragTarget: ShortPositionMark | null;
-    dragPoint: 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right' | 'middle' | null;
-    drawingPhase: 'firstPoint' | 'secondPoint' | 'none';
-    adjustingMode: 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right' | 'middle' | null;
-    adjustStartData: {
-        time: number;
-        price: number;
-    } | null;
-}
-export declare class ShortPositionMarkManager implements IMarkManager<ShortPositionMark> {
-    private props;
-    private state;
-    private previewShortPositionMark;
-    private shortPositionMarks;
-    private dragStartData;
-    private isOperating;
-    private firstPointTime;
-    private firstPointPrice;
-    private secondPointTime;
-    private secondPointPrice;
-    constructor(props: ShortPositionMarkManagerProps);
-    clearState(): void;
-    getMarkAtPoint(point: Point): ShortPositionMark | null;
-    getCurrentDragTarget(): ShortPositionMark | null;
-    getCurrentDragPoint(): string | null;
-    getCurrentOperatingMark(): ShortPositionMark | null;
-    getAllMarks(): ShortPositionMark[];
-    cancelOperationMode(): ShortPositionMarkState;
-    setShortPositionMarkMode: () => ShortPositionMarkState;
-    cancelShortPositionMarkMode: () => ShortPositionMarkState;
-    handleMouseDown: (point: Point) => ShortPositionMarkState;
-    private handleExistingMarkInteraction;
-    private completeShortPositionMark;
-    handleMouseMove: (point: Point) => void;
-    handleMouseUp: (point: Point) => ShortPositionMarkState;
-    handleKeyDown: (event: KeyboardEvent) => ShortPositionMarkState;
-    getState(): ShortPositionMarkState;
-    updateProps(newProps: Partial<ShortPositionMarkManagerProps>): void;
-    destroy(): void;
-    getShortPositionMarks(): ShortPositionMark[];
-    removeShortPositionMark(mark: ShortPositionMark): void;
-    isOperatingOnChart(): boolean;
-    private hiddenShortPositionMarks;
-    hideAllMarks(): void;
-    showAllMarks(): void;
-    hideMark(mark: ShortPositionMark): void;
-    showMark(mark: ShortPositionMark): void;
-}

package/dist/components/CandleView/MarkManager/Range/TimePriceRangeMarkManager.d.ts

@@ -1,63 +0,0 @@
-import { ChartSeries } from '../../ChartLayer/ChartTypeManager';
-import { IMarkManager } from '../../Mark/IMarkManager';
-import { TimePriceRangeMark } from '../../Mark/Range/TimePriceRangeMark';
-import { Point } from '../../types';
-export interface TimePriceRangeMarkManagerProps {
-    chartSeries: ChartSeries | null;
-    chart: any;
-    containerRef: React.RefObject<HTMLDivElement | null>;
-    onCloseDrawing?: () => void;
-}
-export interface TimePriceRangeMarkState {
-    isTimePriceRangeMarkMode: boolean;
-    timePriceRangeMarkStartPoint: Point | null;
-    currentTimePriceRangeMark: TimePriceRangeMark | null;
-    isDragging: boolean;
-    dragTarget: TimePriceRangeMark | null;
-    dragPoint: 'start' | 'end' | 'line' | null;
-    drawingPhase: 'firstPoint' | 'secondPoint' | 'none';
-    adjustingMode: 'start' | 'end' | null;
-    adjustStartData: {
-        time: number;
-        price: number;
-    } | null;
-}
-export declare class TimePriceRangeMarkManager implements IMarkManager<TimePriceRangeMark> {
-    private props;
-    private state;
-    private previewTimePriceRangeMark;
-    private timePriceRangeMarks;
-    private dragStartData;
-    private isOperating;
-    private firstPointTime;
-    private firstPointPrice;
-    private secondPointTime;
-    private secondPointPrice;
-    constructor(props: TimePriceRangeMarkManagerProps);
-    clearState(): void;
-    getMarkAtPoint(point: Point): TimePriceRangeMark | null;
-    getCurrentDragTarget(): TimePriceRangeMark | null;
-    getCurrentDragPoint(): string | null;
-    getCurrentOperatingMark(): TimePriceRangeMark | null;
-    getAllMarks(): TimePriceRangeMark[];
-    cancelOperationMode(): TimePriceRangeMarkState;
-    setTimePriceRangeMarkMode: () => TimePriceRangeMarkState;
-    cancelTimePriceRangeMarkMode: () => TimePriceRangeMarkState;
-    handleMouseDown: (point: Point) => TimePriceRangeMarkState;
-    private handleExistingMarkInteraction;
-    private completeTimePriceRangeMark;
-    handleMouseMove: (point: Point) => void;
-    handleMouseUp: (point: Point) => TimePriceRangeMarkState;
-    handleKeyDown: (event: KeyboardEvent) => TimePriceRangeMarkState;
-    getState(): TimePriceRangeMarkState;
-    updateProps(newProps: Partial<TimePriceRangeMarkManagerProps>): void;
-    destroy(): void;
-    getTimePriceRangeMarks(): TimePriceRangeMark[];
-    removeTimePriceRangeMark(mark: TimePriceRangeMark): void;
-    isOperatingOnChart(): boolean;
-    private hiddenTimePriceRangeMarks;
-    hideAllMarks(): void;
-    showAllMarks(): void;
-    hideMark(mark: TimePriceRangeMark): void;
-    showMark(mark: TimePriceRangeMark): void;
-}

package/dist/components/CandleView/MarkManager/Range/TimeRangeMarkManager.d.ts

@@ -1,63 +0,0 @@
-import { ChartSeries } from '../../ChartLayer/ChartTypeManager';
-import { IMarkManager } from '../../Mark/IMarkManager';
-import { TimeRangeMark } from '../../Mark/Range/TimeRangeMark';
-import { Point } from '../../types';
-export interface TimeRangeMarkManagerProps {
-    chartSeries: ChartSeries | null;
-    chart: any;
-    containerRef: React.RefObject<HTMLDivElement | null>;
-    onCloseDrawing?: () => void;
-}
-export interface TimeRangeMarkState {
-    isTimeRangeMarkMode: boolean;
-    timeRangeMarkStartPoint: Point | null;
-    currentTimeRangeMark: TimeRangeMark | null;
-    isDragging: boolean;
-    dragTarget: TimeRangeMark | null;
-    dragPoint: 'start' | 'end' | 'line' | null;
-    drawingPhase: 'firstPoint' | 'secondPoint' | 'none';
-    adjustingMode: 'start' | 'end' | null;
-    adjustStartData: {
-        time: number;
-        price: number;
-    } | null;
-}
-export declare class TimeRangeMarkManager implements IMarkManager<TimeRangeMark> {
-    private props;
-    private state;
-    private previewTimeRangeMark;
-    private timeRangeMarks;
-    private dragStartData;
-    private isOperating;
-    private firstPointPrice;
-    private firstPointTime;
-    private secondPointPrice;
-    private secondPointTime;
-    constructor(props: TimeRangeMarkManagerProps);
-    clearState(): void;
-    getMarkAtPoint(point: Point): TimeRangeMark | null;
-    getCurrentDragTarget(): TimeRangeMark | null;
-    getCurrentDragPoint(): string | null;
-    getCurrentOperatingMark(): TimeRangeMark | null;
-    getAllMarks(): TimeRangeMark[];
-    cancelOperationMode(): TimeRangeMarkState;
-    setTimeRangeMarkMode: () => TimeRangeMarkState;
-    cancelTimeRangeMarkMode: () => TimeRangeMarkState;
-    handleMouseDown: (point: Point) => TimeRangeMarkState;
-    private handleExistingMarkInteraction;
-    private completeTimeRangeMark;
-    handleMouseMove: (point: Point) => void;
-    handleMouseUp: (point: Point) => TimeRangeMarkState;
-    handleKeyDown: (event: KeyboardEvent) => TimeRangeMarkState;
-    getState(): TimeRangeMarkState;
-    updateProps(newProps: Partial<TimeRangeMarkManagerProps>): void;
-    destroy(): void;
-    getTimeRangeMarks(): TimeRangeMark[];
-    removeTimeRangeMark(mark: TimeRangeMark): void;
-    isOperatingOnChart(): boolean;
-    private hiddenTimeRangeMarks;
-    hideAllMarks(): void;
-    showAllMarks(): void;
-    hideMark(mark: TimeRangeMark): void;
-    showMark(mark: TimeRangeMark): void;
-}

package/dist/components/CandleView/MarkManager/Shape/CircleMarkManager.d.ts

@@ -1,53 +0,0 @@
-import { ChartSeries } from '../../ChartLayer/ChartTypeManager';
-import { IMarkManager } from '../../Mark/IMarkManager';
-import { CircleMark } from '../../Mark/Shape/CircleMark';
-import { Point } from '../../types';
-export interface CircleMarkManagerProps {
-    chartSeries: ChartSeries | null;
-    chart: any;
-    containerRef: React.RefObject<HTMLDivElement | null>;
-    onCloseDrawing?: () => void;
-}
-export interface CircleMarkState {
-    isCircleMarkMode: boolean;
-    circleMarkStartPoint: Point | null;
-    currentCircleMark: CircleMark | null;
-    isDragging: boolean;
-    dragTarget: CircleMark | null;
-    dragPoint: 'center' | 'radius' | 'circle' | null;
-    isDrawing: boolean;
-}
-export declare class CircleMarkManager implements IMarkManager<CircleMark> {
-    private props;
-    private state;
-    private previewCircleMark;
-    private circleMarks;
-    private isOperating;
-    private dragStartData;
-    constructor(props: CircleMarkManagerProps);
-    clearState(): void;
-    getMarkAtPoint(point: Point): CircleMark | null;
-    getCurrentDragTarget(): CircleMark | null;
-    getCurrentDragPoint(): string | null;
-    getCurrentOperatingMark(): CircleMark | null;
-    getAllMarks(): CircleMark[];
-    cancelOperationMode(): CircleMarkState;
-    setCircleMarkMode: () => CircleMarkState;
-    cancelCircleMarkMode: () => CircleMarkState;
-    private getValidTimeFromCoordinate;
-    handleMouseDown: (point: Point) => CircleMarkState;
-    handleMouseMove: (point: Point) => void;
-    handleMouseUp: (point: Point) => CircleMarkState;
-    handleKeyDown: (event: KeyboardEvent) => CircleMarkState;
-    getState(): CircleMarkState;
-    updateProps(newProps: Partial<CircleMarkManagerProps>): void;
-    destroy(): void;
-    getCircleMarks(): CircleMark[];
-    removeCircleMark(mark: CircleMark): void;
-    isOperatingOnChart(): boolean;
-    private hiddenCircleMarks;
-    hideAllMarks(): void;
-    showAllMarks(): void;
-    hideMark(mark: CircleMark): void;
-    showMark(mark: CircleMark): void;
-}

package/dist/components/CandleView/MarkManager/Shape/CurveMarkManager.d.ts

@@ -1,53 +0,0 @@
-import { ChartSeries } from '../../ChartLayer/ChartTypeManager';
-import { IMarkManager } from '../../Mark/IMarkManager';
-import { CurveMark } from '../../Mark/Shape/CurveMark';
-import { Point } from '../../types';
-export interface CurveMarkManagerProps {
-    chartSeries: ChartSeries | null;
-    chart: any;
-    containerRef: React.RefObject<HTMLDivElement | null>;
-    onCloseDrawing?: () => void;
-}
-export interface CurveMarkState {
-    isCurveMarkMode: boolean;
-    curveMarkStartPoint: Point | null;
-    currentCurveMark: CurveMark | null;
-    isDragging: boolean;
-    dragTarget: CurveMark | null;
-    dragPoint: 'start' | 'end' | 'line' | 'mid' | null;
-}
-export declare class CurveMarkManager implements IMarkManager<CurveMark> {
-    private props;
-    private state;
-    private previewCurveMark;
-    private curveMarks;
-    private dragStartData;
-    private isOperating;
-    constructor(props: CurveMarkManagerProps);
-    clearState(): void;
-    getMarkAtPoint(point: Point): CurveMark | null;
-    getCurrentDragTarget(): CurveMark | null;
-    getCurrentDragPoint(): string | null;
-    getCurrentOperatingMark(): CurveMark | null;
-    getAllMarks(): CurveMark[];
-    cancelOperationMode(): CurveMarkState;
-    setCurveMarkMode: () => CurveMarkState;
-    cancelCurveMarkMode: () => CurveMarkState;
-    handleMouseDown: (point: Point) => CurveMarkState;
-    private isPointNearLine;
-    handleMouseMove: (point: Point) => void;
-    private quadraticBezierPoint;
-    handleMouseUp: (point: Point) => CurveMarkState;
-    handleKeyDown: (event: KeyboardEvent) => CurveMarkState;
-    getState(): CurveMarkState;
-    updateProps(newProps: Partial<CurveMarkManagerProps>): void;
-    destroy(): void;
-    getCurveMarks(): CurveMark[];
-    removeCurveMark(mark: CurveMark): void;
-    isOperatingOnChart(): boolean;
-    private hiddenCurveMarks;
-    hideAllMarks(): void;
-    showAllMarks(): void;
-    hideMark(mark: CurveMark): void;
-    showMark(mark: CurveMark): void;
-}

package/dist/components/CandleView/MarkManager/Shape/DoubleCurveMarkManager.d.ts

@@ -1,54 +0,0 @@
-import { ChartSeries } from '../../ChartLayer/ChartTypeManager';
-import { IMarkManager } from '../../Mark/IMarkManager';
-import { DoubleCurveMark } from '../../Mark/Shape/DoubleCurveMark';
-import { Point } from '../../types';
-export interface DoubleCurveMarkManagerProps {
-    chartSeries: ChartSeries | null;
-    chart: any;
-    containerRef: React.RefObject<HTMLDivElement | null>;
-    onCloseDrawing?: () => void;
-}
-export interface DoubleCurveMarkState {
-    isDoubleCurveMarkMode: boolean;
-    doubleCurveMarkStartPoint: Point | null;
-    currentDoubleCurveMark: DoubleCurveMark | null;
-    isDragging: boolean;
-    dragTarget: DoubleCurveMark | null;
-    dragPoint: 'start' | 'end' | 'line' | 'mid1' | 'mid2' | null;
-}
-export declare class DoubleCurveMarkManager implements IMarkManager<DoubleCurveMark> {
-    private props;
-    private state;
-    private previewDoubleCurveMark;
-    private curveMarks;
-    private mouseDownPoint;
-    private dragStartData;
-    private isOperating;
-    constructor(props: DoubleCurveMarkManagerProps);
-    clearState(): void;
-    getMarkAtPoint(point: Point): DoubleCurveMark | null;
-    getCurrentDragTarget(): DoubleCurveMark | null;
-    getCurrentDragPoint(): string | null;
-    getCurrentOperatingMark(): DoubleCurveMark | null;
-    getAllMarks(): DoubleCurveMark[];
-    cancelOperationMode(): DoubleCurveMarkState;
-    setDoubleCurveMarkMode: () => DoubleCurveMarkState;
-    cancelDoubleCurveMarkMode: () => DoubleCurveMarkState;
-    handleMouseDown: (point: Point) => DoubleCurveMarkState;
-    private isPointNearLine;
-    private cubicBezierPoint;
-    handleMouseMove: (point: Point) => void;
-    handleMouseUp: (point: Point) => DoubleCurveMarkState;
-    handleKeyDown: (event: KeyboardEvent) => DoubleCurveMarkState;
-    getState(): DoubleCurveMarkState;
-    updateProps(newProps: Partial<DoubleCurveMarkManagerProps>): void;
-    destroy(): void;
-    getDoubleCurveMarks(): DoubleCurveMark[];
-    removeDoubleCurveMark(mark: DoubleCurveMark): void;
-    isOperatingOnChart(): boolean;
-    private hiddenCurveMarks;
-    hideAllMarks(): void;
-    showAllMarks(): void;
-    hideMark(mark: DoubleCurveMark): void;
-    showMark(mark: DoubleCurveMark): void;
-}

package/dist/components/CandleView/MarkManager/Shape/EllipseMarkManager.d.ts

@@ -1,55 +0,0 @@
-import { ChartSeries } from '../../ChartLayer/ChartTypeManager';
-import { IMarkManager } from '../../Mark/IMarkManager';
-import { EllipseMark } from '../../Mark/Shape/EllipseMark';
-import { Point } from '../../types';
-export interface EllipseMarkManagerProps {
-    chartSeries: ChartSeries | null;
-    chart: any;
-    containerRef: React.RefObject<HTMLDivElement | null>;
-    onCloseDrawing?: () => void;
-}
-export interface EllipseMarkState {
-    isEllipseMarkMode: boolean;
-    ellipseMarkStartPoint: Point | null;
-    currentEllipseMark: EllipseMark | null;
-    isDragging: boolean;
-    dragTarget: EllipseMark | null;
-    dragPoint: 'center' | 'top' | 'bottom' | 'left' | 'right' | 'rotate' | 'ellipse' | null;
-    isDrawing: boolean;
-}
-export declare class EllipseMarkManager implements IMarkManager<EllipseMark> {
-    private props;
-    private state;
-    private previewEllipseMark;
-    private ellipseMarks;
-    private isOperating;
-    private dragStartData;
-    constructor(props: EllipseMarkManagerProps);
-    clearState(): void;
-    getMarkAtPoint(point: Point): EllipseMark | null;
-    getCurrentDragTarget(): EllipseMark | null;
-    getCurrentDragPoint(): string | null;
-    getCurrentOperatingMark(): EllipseMark | null;
-    getAllMarks(): EllipseMark[];
-    cancelOperationMode(): EllipseMarkState;
-    setEllipseMarkMode: () => EllipseMarkState;
-    cancelEllipseMarkMode: () => EllipseMarkState;
-    private getValidTimeFromCoordinate;
-    handleMouseDown: (point: Point) => EllipseMarkState;
-    handleMouseMove: (point: Point) => void;
-    private handleControlPointDrag;
-    handleMouseUp: (point: Point) => EllipseMarkState;
-    handleKeyDown: (event: KeyboardEvent) => EllipseMarkState;
-    getState(): EllipseMarkState;
-    updateProps(newProps: Partial<EllipseMarkManagerProps>): void;
-    destroy(): void;
-    getEllipseMarks(): EllipseMark[];
-    removeEllipseMark(mark: EllipseMark): void;
-    isOperatingOnChart(): boolean;
-    onChartUpdate(): void;
-    private hiddenEllipseMarks;
-    hideAllMarks(): void;
-    showAllMarks(): void;
-    hideMark(mark: EllipseMark): void;
-    showMark(mark: EllipseMark): void;
-}

package/dist/components/CandleView/MarkManager/Shape/RectangleMarkManager.d.ts

@@ -1,51 +0,0 @@
-import { ChartSeries } from '../../ChartLayer/ChartTypeManager';
-import { IMarkManager } from '../../Mark/IMarkManager';
-import { RectangleMark } from '../../Mark/Shape/RectangleMark.ts';
-import { Point } from '../../types';
-export interface RectangleMarkManagerProps {
-    chartSeries: ChartSeries | null;
-    chart: any;
-    containerRef: React.RefObject<HTMLDivElement | null>;
-    onCloseDrawing?: () => void;
-}
-export interface RectangleMarkState {
-    isRectangleMarkMode: boolean;
-    rectangleMarkStartPoint: Point | null;
-    currentRectangleMark: RectangleMark | null;
-    isDragging: boolean;
-    dragTarget: RectangleMark | null;
-    dragPoint: 'start' | 'end' | 'line' | null;
-}
-export declare class RectangleMarkManager implements IMarkManager<RectangleMark> {
-    private props;
-    private state;
-    private previewRectangleMark;
-    private rectangleMarks;
-    private dragStartData;
-    private isOperating;
-    constructor(props: RectangleMarkManagerProps);
-    clearState(): void;
-    getMarkAtPoint(point: Point): RectangleMark | null;
-    getCurrentDragTarget(): RectangleMark | null;
-    getCurrentDragPoint(): string | null;
-    getCurrentOperatingMark(): RectangleMark | null;
-    getAllMarks(): RectangleMark[];
-    cancelOperationMode(): RectangleMarkState;
-    setRectangleMarkMode: () => RectangleMarkState;
-    cancelRectangleMarkMode: () => RectangleMarkState;
-    handleMouseDown: (point: Point) => RectangleMarkState;
-    handleMouseMove: (point: Point) => void;
-    handleMouseUp: (point: Point) => RectangleMarkState;
-    handleKeyDown: (event: KeyboardEvent) => RectangleMarkState;
-    getState(): RectangleMarkState;
-    updateProps(newProps: Partial<RectangleMarkManagerProps>): void;
-    destroy(): void;
-    getRectangleMarks(): RectangleMark[];
-    removeRectangleMark(mark: RectangleMark): void;
-    isOperatingOnChart(): boolean;
-    private hiddenRectangleMarks;
-    hideAllMarks(): void;
-    showAllMarks(): void;
-    hideMark(mark: RectangleMark): void;
-    showMark(mark: RectangleMark): void;
-}

package/dist/components/CandleView/MarkManager/Shape/SectorMarkManager.d.ts

@@ -1,53 +0,0 @@
-import { ChartSeries } from '../../ChartLayer/ChartTypeManager';
-import { IMarkManager } from '../../Mark/IMarkManager';
-import { SectorMark } from '../../Mark/Shape/SectorMark';
-import { Point } from '../../types';
-export interface SectorMarkManagerProps {
-    chartSeries: ChartSeries | null;
-    chart: any;
-    containerRef: React.RefObject<HTMLDivElement | null>;
-    onCloseDrawing?: () => void;
-}
-export interface SectorMarkState {
-    isSectorMode: boolean;
-    sectorPoints: Point[];
-    currentSector: SectorMark | null;
-    isDragging: boolean;
-    dragTarget: SectorMark | null;
-    dragPoint: 'center' | 'radius' | 'angle' | 'sector' | null;
-}
-export declare class SectorMarkManager implements IMarkManager<SectorMark> {
-    private props;
-    private state;
-    private previewSectorMark;
-    private sectorMarks;
-    private dragStartData;
-    private isOperating;
-    constructor(props: SectorMarkManagerProps);
-    clearState(): void;
-    getMarkAtPoint(point: Point): SectorMark | null;
-    getCurrentDragTarget(): SectorMark | null;
-    getCurrentDragPoint(): string | null;
-    getCurrentOperatingMark(): SectorMark | null;
-    getAllMarks(): SectorMark[];
-    cancelOperationMode(): SectorMarkState;
-    setSectorMode: () => SectorMarkState;
-    cancelSectorMode: () => SectorMarkState;
-    handleMouseDown: (point: Point) => SectorMarkState;
-    private coordinateToPriceFallback;
-    private priceToCoordinateFallback;
-    handleMouseMove: (point: Point) => void;
-    handleMouseUp: (point: Point) => SectorMarkState;
-    handleKeyDown: (event: KeyboardEvent) => SectorMarkState;
-    getState(): SectorMarkState;
-    updateProps(newProps: Partial<SectorMarkManagerProps>): void;
-    destroy(): void;
-    getSectorMarks(): SectorMark[];
-    removeSectorMark(mark: SectorMark): void;
-    isOperatingOnChart(): boolean;
-    private hiddenSectorMarks;
-    hideAllMarks(): void;
-    showAllMarks(): void;
-    hideMark(mark: SectorMark): void;
-    showMark(mark: SectorMark): void;
-}

package/dist/components/CandleView/MarkManager/Shape/TriangleMarkManager.d.ts

@@ -1,53 +0,0 @@
-import { ChartSeries } from '../../ChartLayer/ChartTypeManager';
-import { Point } from '../../types';
-import { TriangleMark } from '../../Mark/Shape/TriangleMark';
-import { IMarkManager } from '../../Mark/IMarkManager';
-export interface TriangleMarkManagerProps {
-    chartSeries: ChartSeries | null;
-    chart: any;
-    containerRef: React.RefObject<HTMLDivElement | null>;
-    onCloseDrawing?: () => void;
-}
-export interface TriangleMarkState {
-    isTriangleMarkMode: boolean;
-    triangleMarkStartPoint: Point | null;
-    currentTriangleMark: TriangleMark | null;
-    isDragging: boolean;
-    dragTarget: TriangleMark | null;
-    dragPoint: 'center' | 'vertex1' | 'vertex2' | 'vertex3' | 'triangle' | 'rotation' | null;
-    isDrawing: boolean;
-}
-export declare class TriangleMarkManager implements IMarkManager<TriangleMark> {
-    private props;
-    private state;
-    private previewTriangleMark;
-    private triangleMarks;
-    private isOperating;
-    private dragStartData;
-    constructor(props: TriangleMarkManagerProps);
-    clearState(): void;
-    getMarkAtPoint(point: Point): TriangleMark | null;
-    getCurrentDragTarget(): TriangleMark | null;
-    getCurrentDragPoint(): string | null;
-    getCurrentOperatingMark(): TriangleMark | null;
-    getAllMarks(): TriangleMark[];
-    cancelOperationMode(): TriangleMarkState;
-    setTriangleMarkMode: () => TriangleMarkState;
-    cancelTriangleMarkMode: () => TriangleMarkState;
-    private getValidTimeFromCoordinate;
-    handleMouseDown: (point: Point) => TriangleMarkState;
-    handleMouseMove: (point: Point) => void;
-    handleMouseUp: (point: Point) => TriangleMarkState;
-    handleKeyDown: (event: KeyboardEvent) => TriangleMarkState;
-    getState(): TriangleMarkState;
-    updateProps(newProps: Partial<TriangleMarkManagerProps>): void;
-    destroy(): void;
-    getTriangleMarks(): TriangleMark[];
-    removeTriangleMark(mark: TriangleMark): void;
-    isOperatingOnChart(): boolean;
-    private hiddenTriangleMarks;
-    hideAllMarks(): void;
-    showAllMarks(): void;
-    hideMark(mark: TriangleMark): void;
-    showMark(mark: TriangleMark): void;
-}

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

@@ -1,46 +0,0 @@
-import { ChartSeries } from '../ChartLayer/ChartTypeManager';
-export declare enum StaticMarkDirection {
-    Top = "Top",
-    Bottom = "Bottom"
-}
-export declare enum StaticMarkType {
-    Text = "Text",
-    Arrow = "Arrow"
-}
-export interface IStaticMarkData {
-    time: number;
-    type: string;
-    data: {
-        direction: string;
-        text: string;
-        fontSize?: number;
-        textColor?: string;
-        backgroundColor?: string;
-        isCircular?: boolean;
-        padding?: number;
-    }[];
-}
-export declare class StaticMarkManager {
-    private _marks;
-    private _tolerance;
-    private _timeframe;
-    private _chartSeries;
-    constructor();
-    private autoDetectTimeframe;
-    private median;
-    private calculateTolerance;
-    private findClosestBarTime;
-    private isInSameTimeUnit;
-    private getWeekNumber;
-    addMark(data: IStaticMarkData[], chartSeries: ChartSeries): void;
-    recalculateMarks(): void;
-    refreshTimeframe(): void;
-    private addTopMark;
-    private addBottomMark;
-    removeAllMark(): void;
-    getTolerance(): number;
-    getTimeframe(): string;
-    getMarkCount(): number;
-    clearAllMarks(chartSeries?: ChartSeries): void;
-    destroy(): void;
-}