candleview 1.0.4 → 1.0.5

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

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

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

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

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

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

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

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

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

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

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

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

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