candleview 1.0.0

package/dist/components/CandleView/MarkManager/Map/HeatMapMarkManager.d.ts

@@ -0,0 +1,65 @@
+/// <reference types="react" />
+import { ChartSeries } from "../../ChartLayer/ChartTypeManager";
+import { IMarkManager } from "../../Mark/IMarkManager";
+import { HeatMapMark } from "../../Mark/Map/HeatMapMark";
+import { Point } from "../../types";
+export interface HeatMapMarkManagerProps {
+    chartSeries: ChartSeries | null;
+    chart: any;
+    containerRef: React.RefObject<HTMLDivElement | null>;
+    onCloseDrawing?: () => void;
+}
+export interface HeatMapMarkState {
+    isHeatMapMode: boolean;
+    heatMapStartPoint: Point | null;
+    currentHeatMap: HeatMapMark | null;
+    isDragging: boolean;
+    dragTarget: HeatMapMark | null;
+    dragPoint: 'start' | 'end' | 'body' | null;
+    drawingPhase: 'firstPoint' | 'secondPoint' | 'none';
+    adjustingMode: 'start' | 'end' | 'body' | null;
+    adjustStartData: {
+        time: number;
+        price: number;
+        opacity: number;
+    } | null;
+}
+export declare class HeatMapMarkManager implements IMarkManager<HeatMapMark> {
+    private props;
+    private state;
+    private previewHeatMap;
+    private heatMapMarks;
+    private isOperating;
+    private firstPointTime;
+    private firstPointPrice;
+    private secondPointTime;
+    private secondPointPrice;
+    private dragStartPoint;
+    constructor(props: HeatMapMarkManagerProps);
+    clearState(): void;
+    getMarkAtPoint(point: Point): HeatMapMark | null;
+    getCurrentDragTarget(): HeatMapMark | null;
+    getCurrentDragPoint(): string | null;
+    getCurrentOperatingMark(): HeatMapMark | null;
+    getAllMarks(): HeatMapMark[];
+    cancelOperationMode(): HeatMapMarkState;
+    setHeatMapMode: () => HeatMapMarkState;
+    cancelHeatMapMode: () => HeatMapMarkState;
+    handleMouseDown: (point: Point) => HeatMapMarkState;
+    private handleDrawingPhaseMouseDown;
+    handleMouseMove: (point: Point) => void;
+    private isPointInHeatMapArea;
+    handleMouseUp: (point: Point) => HeatMapMarkState;
+    handleKeyDown: (event: KeyboardEvent) => HeatMapMarkState;
+    getState(): HeatMapMarkState;
+    updateProps(newProps: Partial<HeatMapMarkManagerProps>): void;
+    destroy(): void;
+    getHeatMapMarks(): HeatMapMark[];
+    removeHeatMapMark(mark: HeatMapMark): void;
+    isOperatingOnChart(): boolean;
+    private hiddenHeatMapMarks;
+    hideAllMarks(): void;
+    showAllMarks(): void;
+    hideMark(mark: HeatMapMark): void;
+    showMark(mark: HeatMapMark): void;
+}

package/dist/components/CandleView/MarkManager/Mock/MockKLineMarkManager.d.ts

@@ -0,0 +1,53 @@
+/// <reference types="react" />
+import { ChartSeries } from "../../ChartLayer/ChartTypeManager";
+import { IMarkManager } from "../../Mark/IMarkManager";
+import { MockKLineMark } from "../../Mark/Mock/MockKLineMark";
+import { Point } from "../../types";
+export interface MockKLineMarkManagerProps {
+    chartSeries: ChartSeries | null;
+    chart: any;
+    containerRef: React.RefObject<HTMLDivElement | null>;
+    onCloseDrawing?: () => void;
+}
+export interface MockKLineMarkState {
+    isMockKLineMarkMode: boolean;
+    mockKLineMarkStartPoint: Point | null;
+    currentMockKLineMark: MockKLineMark | null;
+    isDragging: boolean;
+    dragTarget: MockKLineMark | null;
+    dragPoint: 'start' | 'end' | 'line' | null;
+}
+export declare class MockKLineMarkManager implements IMarkManager<MockKLineMark> {
+    private props;
+    private state;
+    private previewMockKLineMark;
+    private mockKLineMarks;
+    private dragStartData;
+    private isOperating;
+    constructor(props: MockKLineMarkManagerProps);
+    clearState(): void;
+    getMarkAtPoint(point: Point): MockKLineMark | null;
+    getCurrentDragTarget(): MockKLineMark | null;
+    getCurrentDragPoint(): string | null;
+    getCurrentOperatingMark(): MockKLineMark | null;
+    getAllMarks(): MockKLineMark[];
+    cancelOperationMode(): MockKLineMarkState;
+    setMockKLineMarkMode: () => MockKLineMarkState;
+    cancelMockKLineMarkMode: () => MockKLineMarkState;
+    handleMouseDown: (point: Point) => MockKLineMarkState;
+    private isPointNearLine;
+    handleMouseMove: (point: Point) => void;
+    handleMouseUp: (point: Point) => MockKLineMarkState;
+    handleKeyDown: (event: KeyboardEvent) => MockKLineMarkState;
+    getState(): MockKLineMarkState;
+    updateProps(newProps: Partial<MockKLineMarkManagerProps>): void;
+    destroy(): void;
+    getMockKLineMarks(): MockKLineMark[];
+    removeMockKLineMark(mark: MockKLineMark): void;
+    isOperatingOnChart(): boolean;
+    private hiddenMockKLineMarks;
+    hideAllMarks(): void;
+    showAllMarks(): void;
+    hideMark(mark: MockKLineMark): void;
+    showMark(mark: MockKLineMark): void;
+}

package/dist/components/CandleView/MarkManager/Pattern/ABCDMarkManager.d.ts

@@ -0,0 +1,54 @@
+/// <reference types="react" />
+import { ChartSeries } from "../../ChartLayer/ChartTypeManager";
+import { IMarkManager } from "../../Mark/IMarkManager";
+import { ABCDMark } from "../../Mark/Pattern/ABCDMark";
+import { Point } from "../../types";
+export interface ABCDMarkManagerProps {
+    chartSeries: ChartSeries | null;
+    chart: any;
+    containerRef: React.RefObject<HTMLDivElement | null>;
+    onCloseDrawing?: () => void;
+}
+export interface ABCDMarkState {
+    isABCDMode: boolean;
+    currentPoints: Point[];
+    currentABCDMark: ABCDMark | null;
+    isDragging: boolean;
+    dragTarget: ABCDMark | null;
+    dragPoint: number | null;
+}
+export declare class ABCDMarkManager implements IMarkManager<ABCDMark> {
+    private props;
+    private state;
+    private previewMark;
+    private abcdMarks;
+    private mouseDownPoint;
+    private dragStartData;
+    private isOperating;
+    private defaultColor;
+    constructor(props: ABCDMarkManagerProps);
+    clearState(): void;
+    getMarkAtPoint(point: Point): ABCDMark | null;
+    getCurrentDragTarget(): ABCDMark | null;
+    getCurrentDragPoint(): string | null;
+    getCurrentOperatingMark(): ABCDMark | null;
+    getAllMarks(): ABCDMark[];
+    cancelOperationMode(): ABCDMarkState;
+    setABCDMode: () => ABCDMarkState;
+    cancelABCDMode: () => ABCDMarkState;
+    handleMouseDown: (point: Point) => ABCDMarkState;
+    handleMouseMove: (point: Point) => void;
+    handleMouseUp: (point: Point) => ABCDMarkState;
+    handleKeyDown: (event: KeyboardEvent) => ABCDMarkState;
+    getState(): ABCDMarkState;
+    updateProps(newProps: Partial<ABCDMarkManagerProps>): void;
+    destroy(): void;
+    getABCDMarks(): ABCDMark[];
+    removeABCDMark(mark: ABCDMark): void;
+    isOperatingOnChart(): boolean;
+    private hiddenABCDMarks;
+    hideAllMarks(): void;
+    showAllMarks(): void;
+    hideMark(mark: ABCDMark): void;
+    showMark(mark: ABCDMark): void;
+}

package/dist/components/CandleView/MarkManager/Pattern/HeadAndShouldersMarkManager.d.ts

@@ -0,0 +1,54 @@
+/// <reference types="react" />
+import { ChartSeries } from "../../ChartLayer/ChartTypeManager";
+import { IMarkManager } from "../../Mark/IMarkManager";
+import { HeadAndShouldersMark } from "../../Mark/Pattern/HeadAndShouldersMark";
+import { Point } from "../../types";
+export interface HeadAndShouldersMarkManagerProps {
+    chartSeries: ChartSeries | null;
+    chart: any;
+    containerRef: React.RefObject<HTMLDivElement | null>;
+    onCloseDrawing?: () => void;
+}
+export interface HeadAndShouldersMarkState {
+    isHeadAndShouldersMode: boolean;
+    currentPoints: Point[];
+    currentHeadAndShouldersMark: HeadAndShouldersMark | null;
+    isDragging: boolean;
+    dragTarget: HeadAndShouldersMark | null;
+    dragPoint: number | null;
+}
+export declare class HeadAndShouldersMarkManager implements IMarkManager<HeadAndShouldersMark> {
+    private props;
+    private state;
+    private previewMark;
+    private headAndShouldersMarks;
+    private mouseDownPoint;
+    private dragStartData;
+    private isOperating;
+    private defaultColor;
+    constructor(props: HeadAndShouldersMarkManagerProps);
+    clearState(): void;
+    getMarkAtPoint(point: Point): HeadAndShouldersMark | null;
+    getCurrentDragTarget(): HeadAndShouldersMark | null;
+    getCurrentDragPoint(): string | null;
+    getCurrentOperatingMark(): HeadAndShouldersMark | null;
+    getAllMarks(): HeadAndShouldersMark[];
+    cancelOperationMode(): HeadAndShouldersMarkState;
+    setHeadAndShouldersMode: () => HeadAndShouldersMarkState;
+    cancelHeadAndShouldersMode: () => HeadAndShouldersMarkState;
+    handleMouseDown: (point: Point) => HeadAndShouldersMarkState;
+    handleMouseMove: (point: Point) => void;
+    handleMouseUp: (point: Point) => HeadAndShouldersMarkState;
+    handleKeyDown: (event: KeyboardEvent) => HeadAndShouldersMarkState;
+    getState(): HeadAndShouldersMarkState;
+    updateProps(newProps: Partial<HeadAndShouldersMarkManagerProps>): void;
+    destroy(): void;
+    getHeadAndShouldersMarks(): HeadAndShouldersMark[];
+    removeHeadAndShouldersMark(mark: HeadAndShouldersMark): void;
+    isOperatingOnChart(): boolean;
+    private hiddenHeadAndShouldersMarks;
+    hideAllMarks(): void;
+    showAllMarks(): void;
+    hideMark(mark: HeadAndShouldersMark): void;
+    showMark(mark: HeadAndShouldersMark): void;
+}

package/dist/components/CandleView/MarkManager/Pattern/TriangleABCDMarkManager.d.ts

@@ -0,0 +1,55 @@
+/// <reference types="react" />
+import { ChartSeries } from "../../ChartLayer/ChartTypeManager";
+import { Point } from "../../types";
+import { IMarkManager } from "../../Mark/IMarkManager";
+import { TriangleABCDMark } from "../../Mark/Pattern/TriangleABCDMark";
+export interface TriangleABCDMarkManagerProps {
+    chartSeries: ChartSeries | null;
+    chart: any;
+    containerRef: React.RefObject<HTMLDivElement | null>;
+    onCloseDrawing?: () => void;
+}
+export interface TriangleABCDMarkState {
+    isGlassTriangleABCDMode: boolean;
+    currentPoints: Point[];
+    currentTriangleABCDMark: TriangleABCDMark | null;
+    isDragging: boolean;
+    dragTarget: TriangleABCDMark | null;
+    dragPoint: number | null;
+}
+export declare class TriangleABCDMarkManager implements IMarkManager<TriangleABCDMark> {
+    private props;
+    private state;
+    private previewMark;
+    private TriangleABCDMarks;
+    private mouseDownPoint;
+    private dragStartData;
+    private isOperating;
+    private defaultColor;
+    private lastMousePoint;
+    constructor(props: TriangleABCDMarkManagerProps);
+    clearState(): void;
+    getMarkAtPoint(point: Point): TriangleABCDMark | null;
+    getCurrentDragTarget(): TriangleABCDMark | null;
+    getCurrentDragPoint(): string | null;
+    getCurrentOperatingMark(): TriangleABCDMark | null;
+    getAllMarks(): TriangleABCDMark[];
+    cancelOperationMode(): TriangleABCDMarkState;
+    setGlassTriangleABCDMode: () => TriangleABCDMarkState;
+    cancelGlassTriangleABCDMode: () => TriangleABCDMarkState;
+    handleMouseDown: (point: Point) => TriangleABCDMarkState;
+    handleMouseMove: (point: Point) => void;
+    handleMouseUp: (point: Point) => TriangleABCDMarkState;
+    handleKeyDown: (event: KeyboardEvent) => TriangleABCDMarkState;
+    getState(): TriangleABCDMarkState;
+    updateProps(newProps: Partial<TriangleABCDMarkManagerProps>): void;
+    destroy(): void;
+    getTriangleABCDMarks(): TriangleABCDMark[];
+    removeTriangleABCDMark(mark: TriangleABCDMark): void;
+    isOperatingOnChart(): boolean;
+    private hiddenTriangleABCDMarks;
+    hideAllMarks(): void;
+    showAllMarks(): void;
+    hideMark(mark: TriangleABCDMark): void;
+    showMark(mark: TriangleABCDMark): void;
+}

package/dist/components/CandleView/MarkManager/Pattern/XABCDMarkManager.d.ts

@@ -0,0 +1,54 @@
+/// <reference types="react" />
+import { ChartSeries } from "../../ChartLayer/ChartTypeManager";
+import { Point } from "../../types";
+import { IMarkManager } from "../../Mark/IMarkManager";
+import { XABCDMark } from "../../Mark/Pattern/XABCDMark";
+export interface XABCDMarkManagerProps {
+    chartSeries: ChartSeries | null;
+    chart: any;
+    containerRef: React.RefObject<HTMLDivElement | null>;
+    onCloseDrawing?: () => void;
+}
+export interface XABCDMarkState {
+    isXABCDMode: boolean;
+    currentPoints: Point[];
+    currentXABCDMark: XABCDMark | null;
+    isDragging: boolean;
+    dragTarget: XABCDMark | null;
+    dragPoint: number | null;
+}
+export declare class XABCDMarkManager implements IMarkManager<XABCDMark> {
+    private props;
+    private state;
+    private previewMark;
+    private xabcdMarks;
+    private mouseDownPoint;
+    private dragStartData;
+    private isOperating;
+    private defaultColor;
+    constructor(props: XABCDMarkManagerProps);
+    clearState(): void;
+    getMarkAtPoint(point: Point): XABCDMark | null;
+    getCurrentDragTarget(): XABCDMark | null;
+    getCurrentDragPoint(): string | null;
+    getCurrentOperatingMark(): XABCDMark | null;
+    getAllMarks(): XABCDMark[];
+    cancelOperationMode(): XABCDMarkState;
+    setXABCDMode: () => XABCDMarkState;
+    cancelXABCDMode: () => XABCDMarkState;
+    handleMouseDown: (point: Point) => XABCDMarkState;
+    handleMouseMove: (point: Point) => void;
+    handleMouseUp: (point: Point) => XABCDMarkState;
+    handleKeyDown: (event: KeyboardEvent) => XABCDMarkState;
+    getState(): XABCDMarkState;
+    updateProps(newProps: Partial<XABCDMarkManagerProps>): void;
+    destroy(): void;
+    getXABCDMarks(): XABCDMark[];
+    removeXABCDMark(mark: XABCDMark): void;
+    isOperatingOnChart(): boolean;
+    private hiddenXABCDMarks;
+    hideAllMarks(): void;
+    showAllMarks(): void;
+    hideMark(mark: XABCDMark): void;
+    showMark(mark: XABCDMark): void;
+}

package/dist/components/CandleView/MarkManager/Pen/BrushMarkManager.d.ts

@@ -0,0 +1,56 @@
+/// <reference types="react" />
+import { ChartSeries } from "../../ChartLayer/ChartTypeManager";
+import { IMarkManager } from "../../Mark/IMarkManager";
+import { BrushMark } from "../../Mark/Pen/BrushMark";
+import { Point } from "../../types";
+export interface BrushMarkManagerProps {
+    chartSeries: ChartSeries | null;
+    chart: any;
+    containerRef: React.RefObject<HTMLDivElement | null>;
+    onCloseDrawing?: () => void;
+}
+export interface BrushMarkState {
+    isBrushMode: boolean;
+    isDrawing: boolean;
+    currentBrushMark: BrushMark | null;
+    isDragging: boolean;
+    dragTarget: BrushMark | null;
+}
+export declare class BrushMarkManager implements IMarkManager<BrushMark> {
+    private props;
+    private state;
+    private BrushMarks;
+    private dragStartData;
+    private isOperating;
+    private lastPoint;
+    private pointThreshold;
+    private lineWidth;
+    constructor(props: BrushMarkManagerProps);
+    clearState(): void;
+    private updateCursor;
+    getCurrentDragPoint(): string | null;
+    getMarkAtPoint(point: Point): BrushMark | null;
+    getCurrentDragTarget(): BrushMark | null;
+    getCurrentOperatingMark(): BrushMark | null;
+    getAllMarks(): BrushMark[];
+    cancelOperationMode(): BrushMarkState;
+    setBrushMode: () => BrushMarkState;
+    cancelBrushMode: () => BrushMarkState;
+    handleMouseDown: (point: Point) => BrushMarkState;
+    handleMouseMove: (point: Point) => void;
+    handleMouseUp: (point: Point) => BrushMarkState;
+    handleKeyDown: (event: KeyboardEvent) => BrushMarkState;
+    closeBrush: () => BrushMarkState;
+    getState(): BrushMarkState;
+    updateProps(newProps: Partial<BrushMarkManagerProps>): void;
+    destroy(): void;
+    getBrushMarks(): BrushMark[];
+    removeBrushMark(mark: BrushMark): void;
+    isOperatingOnChart(): boolean;
+    setPointThreshold(threshold: number): void;
+    private hiddenBrushMarks;
+    hideAllMarks(): void;
+    showAllMarks(): void;
+    hideMark(mark: BrushMark): void;
+    showMark(mark: BrushMark): void;
+}

package/dist/components/CandleView/MarkManager/Pen/EraserMarkManager.d.ts

@@ -0,0 +1,52 @@
+/// <reference types="react" />
+import { ChartSeries } from "../../ChartLayer/ChartTypeManager";
+import { IDeletableMark } from "../../Mark/IDeletableMark";
+import { IMarkManager } from "../../Mark/IMarkManager";
+import { Point } from "../../types";
+export interface EraserMarkManagerProps {
+    chartSeries: ChartSeries | null;
+    chart: any;
+    containerRef: React.RefObject<HTMLDivElement | null>;
+    onCloseDrawing?: () => void;
+}
+export interface EraserMarkState {
+    isEraserMode: boolean;
+    isErasing: boolean;
+    hoveredMark: IDeletableMark | null;
+}
+export declare class EraserMarkManager implements IMarkManager<IDeletableMark> {
+    private props;
+    private state;
+    private penMarks;
+    private isOperating;
+    constructor(props: EraserMarkManagerProps);
+    clearState(): void;
+    private updateCursor;
+    setEraserMode: () => EraserMarkState;
+    cancelEraserMode: () => EraserMarkState;
+    getMarkAtPoint(point: Point): IDeletableMark | null;
+    private isMarkValid;
+    handleMouseDown: (point: Point) => EraserMarkState;
+    handleMouseMove: (point: Point) => void;
+    handleMouseUp: (point: Point) => EraserMarkState;
+    handleKeyDown: (event: KeyboardEvent) => EraserMarkState;
+    closeBrush: () => EraserMarkState;
+    getCurrentDragPoint(): string | null;
+    getCurrentDragTarget(): IDeletableMark | null;
+    getCurrentOperatingMark(): IDeletableMark | null;
+    getAllMarks(): IDeletableMark[];
+    cancelOperationMode(): EraserMarkState;
+    getState(): EraserMarkState;
+    updateProps(newProps: Partial<EraserMarkManagerProps>): void;
+    destroy(): void;
+    getPenMarks(): IDeletableMark[];
+    removePenMark(mark: IDeletableMark): void;
+    addPenMark(mark: IDeletableMark): void;
+    isOperatingOnChart(): boolean;
+    setPenMarks(marks: IDeletableMark[]): void;
+    private hiddenPenMarks;
+    hideAllMarks(): void;
+    showAllMarks(): void;
+    hideMark(mark: IDeletableMark): void;
+    showMark(mark: IDeletableMark): void;
+}

package/dist/components/CandleView/MarkManager/Pen/MarkerPenMarkManager.d.ts

@@ -0,0 +1,56 @@
+/// <reference types="react" />
+import { ChartSeries } from "../../ChartLayer/ChartTypeManager";
+import { IMarkManager } from "../../Mark/IMarkManager";
+import { MarkerPenMark } from "../../Mark/Pen/MarkerPenMark";
+import { Point } from "../../types";
+export interface MarkerPenMarkManagerProps {
+    chartSeries: ChartSeries | null;
+    chart: any;
+    containerRef: React.RefObject<HTMLDivElement | null>;
+    onCloseDrawing?: () => void;
+}
+export interface MarkerPenMarkState {
+    isMarkerPenMarkMode: boolean;
+    isDrawing: boolean;
+    currentMarkerPenMark: MarkerPenMark | null;
+    isDragging: boolean;
+    dragTarget: MarkerPenMark | null;
+}
+export declare class MarkerPenMarkManager implements IMarkManager<MarkerPenMark> {
+    private props;
+    private state;
+    private MarkerPenMarks;
+    private dragStartData;
+    private isOperating;
+    private lastPoint;
+    private pointThreshold;
+    private lineWidth;
+    constructor(props: MarkerPenMarkManagerProps);
+    clearState(): void;
+    private updateCursor;
+    getCurrentDragPoint(): string | null;
+    getMarkAtPoint(point: Point): MarkerPenMark | null;
+    getCurrentDragTarget(): MarkerPenMark | null;
+    getCurrentOperatingMark(): MarkerPenMark | null;
+    getAllMarks(): MarkerPenMark[];
+    cancelOperationMode(): MarkerPenMarkState;
+    setMarkerPenMarkMode: () => MarkerPenMarkState;
+    cancelMarkerPenMarkMode: () => MarkerPenMarkState;
+    handleMouseDown: (point: Point) => MarkerPenMarkState;
+    handleMouseMove: (point: Point) => void;
+    handleMouseUp: (point: Point) => MarkerPenMarkState;
+    handleKeyDown: (event: KeyboardEvent) => MarkerPenMarkState;
+    closeBrush: () => MarkerPenMarkState;
+    getState(): MarkerPenMarkState;
+    updateProps(newProps: Partial<MarkerPenMarkManagerProps>): void;
+    destroy(): void;
+    getMarkerPenMarks(): MarkerPenMark[];
+    removeMarkerPenMark(mark: MarkerPenMark): void;
+    isOperatingOnChart(): boolean;
+    setPointThreshold(threshold: number): void;
+    private hiddenMarkerPenMarks;
+    hideAllMarks(): void;
+    showAllMarks(): void;
+    hideMark(mark: MarkerPenMark): void;
+    showMark(mark: MarkerPenMark): void;
+}

package/dist/components/CandleView/MarkManager/Pen/PenMarkManager.d.ts

@@ -0,0 +1,56 @@
+/// <reference types="react" />
+import { ChartSeries } from "../../ChartLayer/ChartTypeManager";
+import { IMarkManager } from "../../Mark/IMarkManager";
+import { PenMark } from "../../Mark/Pen/PenMark";
+import { Point } from "../../types";
+export interface PenMarkManagerProps {
+    chartSeries: ChartSeries | null;
+    chart: any;
+    containerRef: React.RefObject<HTMLDivElement | null>;
+    onCloseDrawing?: () => void;
+}
+export interface PenMarkState {
+    isPenMode: boolean;
+    isDrawing: boolean;
+    currentPenMark: PenMark | null;
+    isDragging: boolean;
+    dragTarget: PenMark | null;
+}
+export declare class PenMarkManager implements IMarkManager<PenMark> {
+    private props;
+    private state;
+    private PenMarks;
+    private dragStartData;
+    private isOperating;
+    private lastPoint;
+    private pointThreshold;
+    private lineWidth;
+    constructor(props: PenMarkManagerProps);
+    clearState(): void;
+    private updateCursor;
+    getCurrentDragPoint(): string | null;
+    getMarkAtPoint(point: Point): PenMark | null;
+    getCurrentDragTarget(): PenMark | null;
+    getCurrentOperatingMark(): PenMark | null;
+    getAllMarks(): PenMark[];
+    cancelOperationMode(): PenMarkState;
+    setPenMode: () => PenMarkState;
+    cancelPenMode: () => PenMarkState;
+    handleMouseDown: (point: Point) => PenMarkState;
+    handleMouseMove: (point: Point) => void;
+    handleMouseUp: (point: Point) => PenMarkState;
+    handleKeyDown: (event: KeyboardEvent) => PenMarkState;
+    closeBrush: () => PenMarkState;
+    getState(): PenMarkState;
+    updateProps(newProps: Partial<PenMarkManagerProps>): void;
+    destroy(): void;
+    getPenMarks(): PenMark[];
+    removePenMark(mark: PenMark): void;
+    isOperatingOnChart(): boolean;
+    setPointThreshold(threshold: number): void;
+    private hiddenPenMarks;
+    hideAllMarks(): void;
+    showAllMarks(): void;
+    hideMark(mark: PenMark): void;
+    showMark(mark: PenMark): void;
+}

package/dist/components/CandleView/MarkManager/Pen/PencilMarkManager.d.ts

@@ -0,0 +1,55 @@
+/// <reference types="react" />
+import { ChartSeries } from "../../ChartLayer/ChartTypeManager";
+import { IMarkManager } from "../../Mark/IMarkManager";
+import { PencilMark } from "../../Mark/Pen/PencilMark";
+import { Point } from "../../types";
+export interface PencilMarkManagerProps {
+    chartSeries: ChartSeries | null;
+    chart: any;
+    containerRef: React.RefObject<HTMLDivElement | null>;
+    onCloseDrawing?: () => void;
+}
+export interface PencilMarkState {
+    isPencilMode: boolean;
+    isDrawing: boolean;
+    currentPencilMark: PencilMark | null;
+    isDragging: boolean;
+    dragTarget: PencilMark | null;
+}
+export declare class PencilMarkManager implements IMarkManager<PencilMark> {
+    private props;
+    private state;
+    private PencilMarks;
+    private dragStartData;
+    private isOperating;
+    private lastPoint;
+    private pointThreshold;
+    constructor(props: PencilMarkManagerProps);
+    clearState(): void;
+    private updateCursor;
+    getCurrentDragPoint(): string | null;
+    getMarkAtPoint(point: Point): PencilMark | null;
+    getCurrentDragTarget(): PencilMark | null;
+    getCurrentOperatingMark(): PencilMark | null;
+    getAllMarks(): PencilMark[];
+    cancelOperationMode(): PencilMarkState;
+    setPencilMode: () => PencilMarkState;
+    cancelPencilMode: () => PencilMarkState;
+    handleMouseDown: (point: Point) => PencilMarkState;
+    handleMouseMove: (point: Point) => void;
+    handleMouseUp: (point: Point) => PencilMarkState;
+    handleKeyDown: (event: KeyboardEvent) => PencilMarkState;
+    closeBrush: () => PencilMarkState;
+    getState(): PencilMarkState;
+    updateProps(newProps: Partial<PencilMarkManagerProps>): void;
+    destroy(): void;
+    getPencilMarks(): PencilMark[];
+    removePencilMark(mark: PencilMark): void;
+    isOperatingOnChart(): boolean;
+    setPointThreshold(threshold: number): void;
+    private hiddenPencilMarks;
+    hideAllMarks(): void;
+    showAllMarks(): void;
+    hideMark(mark: PencilMark): void;
+    showMark(mark: PencilMark): void;
+}

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

@@ -0,0 +1,64 @@
+/// <reference types="react" />
+import { ChartSeries } from "../../ChartLayer/ChartTypeManager";
+import { IMarkManager } from "../../Mark/IMarkManager";
+import { LongPositionMark } from "../../Mark/Range/LongPositionMark";
+import { Point } from "../../types";
+export interface LongPositionMarkManagerProps {
+    chartSeries: ChartSeries | null;
+    chart: any;
+    containerRef: React.RefObject<HTMLDivElement | null>;
+    onCloseDrawing?: () => void;
+}
+export interface LongPositionMarkState {
+    isLongPositionMarkMode: boolean;
+    longPositionMarkStartPoint: Point | null;
+    currentLongPositionMark: LongPositionMark | null;
+    isDragging: boolean;
+    dragTarget: LongPositionMark | 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 LongPositionMarkManager implements IMarkManager<LongPositionMark> {
+    private props;
+    private state;
+    private previewLongPositionMark;
+    private longPositionMarks;
+    private dragStartData;
+    private isOperating;
+    private firstPointTime;
+    private firstPointPrice;
+    private secondPointTime;
+    private secondPointPrice;
+    constructor(props: LongPositionMarkManagerProps);
+    clearState(): void;
+    getMarkAtPoint(point: Point): LongPositionMark | null;
+    getCurrentDragTarget(): LongPositionMark | null;
+    getCurrentDragPoint(): string | null;
+    getCurrentOperatingMark(): LongPositionMark | null;
+    getAllMarks(): LongPositionMark[];
+    cancelOperationMode(): LongPositionMarkState;
+    setLongPositionMarkMode: () => LongPositionMarkState;
+    cancelLongPositionMarkMode: () => LongPositionMarkState;
+    handleMouseDown: (point: Point) => LongPositionMarkState;
+    private handleExistingMarkInteraction;
+    private completeLongPositionMark;
+    handleMouseMove: (point: Point) => void;
+    handleMouseUp: (point: Point) => LongPositionMarkState;
+    handleKeyDown: (event: KeyboardEvent) => LongPositionMarkState;
+    getState(): LongPositionMarkState;
+    updateProps(newProps: Partial<LongPositionMarkManagerProps>): void;
+    destroy(): void;
+    getLongPositionMarks(): LongPositionMark[];
+    removeLongPositionMark(mark: LongPositionMark): void;
+    isOperatingOnChart(): boolean;
+    private hiddenLongPositionMarks;
+    hideAllMarks(): void;
+    showAllMarks(): void;
+    hideMark(mark: LongPositionMark): void;
+    showMark(mark: LongPositionMark): void;
+}