candleview 1.0.5 → 1.0.7

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

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

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

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

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

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

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

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

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

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

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

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

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