candleview 1.0.5 → 1.0.7

package/dist/components/CandleView/ChartLayer/index.d.ts

@@ -1,290 +0,0 @@
-import { default as React } from 'react';
-import { ThemeConfig } from '../Theme';
-import { ChartSeries } from './ChartTypeManager';
-import { CursorType, HistoryRecord, ICandleViewDataPoint, MainChartIndicatorType, MainChartType, MarkDrawing, Point, SubChartIndicatorType } from '../types';
-import { IMarkStyle } from '../Mark/IMarkStyle';
-import { ChartMarkManager } from './ChartMarkManager';
-import { ChartMarkTextEditManager } from './ChartMarkTextEditManager';
-import { MainChartTechnicalIndicatorManager } from '../Indicators/MainChart/MainChartIndicatorManager';
-import { ChartMarkState } from './ChartLayerMarkState';
-import { MainChartIndicatorInfo } from '../Indicators/MainChart/MainChartIndicatorInfo';
-import { I18n } from '../I18n';
-import { IStaticMarkData } from '../MarkManager/StaticMarkManager';
-import { ChartPanesManager } from './Panes/ChartPanesManager';
-import { IIndicatorInfo } from '../Indicators/SubChart/IIndicator';
-import { MainChartManager } from './MainChart/MainChartManager';
-import { ViewportManager } from '../ViewportManager';
-export interface ChartLayerProps {
-    chart: any;
-    chartSeries: ChartSeries | null;
-    currentTheme: ThemeConfig;
-    activeTool: string | null;
-    onCloseDrawing?: () => void;
-    onToolSelect?: (tool: string) => void;
-    onTextClick?: (toolId: string) => void;
-    onEmojiClick?: (toolId: string) => void;
-    selectedEmoji?: string;
-    chartData: ICandleViewDataPoint[];
-    title?: string;
-    selectedMainChartIndicator: MainChartIndicatorInfo | null;
-    selectedSubChartIndicators: SubChartIndicatorType[];
-    handleRemoveSubChartIndicator?: (type: SubChartIndicatorType) => void;
-    showInfoLayer: boolean;
-    i18n: I18n;
-    markData?: IStaticMarkData[];
-    onMainChartIndicatorChange: (indicator: MainChartIndicatorInfo | null) => void;
-    currentMainChartType: MainChartType;
-    viewportManager: ViewportManager | null;
-}
-export interface ChartLayerState extends ChartMarkState {
-    isDrawing: boolean;
-    drawingPoints: Point[];
-    currentDrawing: any;
-    drawingStartPoint: Point | null;
-    drawings: MarkDrawing[];
-    isTextMarkToolbar: boolean;
-    dragStartPoint: Point | null;
-    history: HistoryRecord[];
-    historyIndex: number;
-    isDragging: boolean;
-    isResizing: boolean;
-    isRotating: boolean;
-    resizeHandle: string | null;
-    isTextInputActive: boolean;
-    textInputPosition: Point | null;
-    textInputValue: string;
-    textInputCursorVisible: boolean;
-    textInputCursorTimer: NodeJS.Timeout | null;
-    activePanel: null;
-    editingTextId: string | null;
-    isFirstTimeTextMode: boolean;
-    isEmojiInputActive: boolean;
-    emojiInputPosition: Point | null;
-    editingEmojiId: string | null;
-    mousePosition: Point | null;
-    currentOHLC: {
-        time: string;
-        open: number;
-        high: number;
-        low: number;
-        close: number;
-        volume?: number;
-    } | null;
-    showOHLC: boolean;
-    maIndicatorValues?: {
-        [key: string]: number;
-    };
-    emaIndicatorValues?: {
-        [key: string]: number;
-    };
-    bollingerBandsValues?: {
-        [key: string]: number;
-    };
-    ichimokuValues?: {
-        [key: string]: number;
-    };
-    donchianChannelValues?: {
-        [key: string]: number;
-    };
-    envelopeValues?: {
-        [key: string]: number;
-    };
-    vwapValue?: number | null;
-    isMainChartIndicatorsModalOpen: boolean;
-    selectedMainChartIndicators: MainChartIndicatorInfo[];
-    selectedMainChartIndicatorTypes: MainChartIndicatorType[];
-    modalEditingChartInfoIndicator: MainChartIndicatorInfo | null;
-    modalConfirmChartInfoIndicators: MainChartIndicatorInfo[];
-    isSubChartIndicatorsSettingModalOpen: boolean;
-    subChartIndicatorsSettingModalParams: IIndicatorInfo[];
-    currentSubChartIndicatorType: SubChartIndicatorType | null;
-    cursorType: CursorType | null;
-}
-declare class ChartLayer extends React.Component<ChartLayerProps, ChartLayerState> {
-    canvasRef: React.RefObject<HTMLCanvasElement | null>;
-    containerRef: React.RefObject<HTMLDivElement | null>;
-    allDrawings: MarkDrawing[];
-    private doubleClickTimeout;
-    private chartEventManager;
-    private originalChartOptions;
-    currentMarkSettingsStyle: IMarkStyle | null;
-    chartMarkManager: ChartMarkManager | null;
-    chartMarkTextEditManager: ChartMarkTextEditManager | null;
-    mainChartTechnicalIndicatorManager: MainChartTechnicalIndicatorManager | null;
-    private staticMarkManager;
-    chartPanesManager: ChartPanesManager | null;
-    private volume;
-    private volumeHeatMap;
-    private marketProfile;
-    mainChartManager: MainChartManager | null;
-    constructor(props: ChartLayerProps);
-    componentDidMount(): void;
-    componentDidUpdate(prevProps: ChartLayerProps): void;
-    componentWillUnmount(): void;
-    private handleInitMainChartMaps;
-    private handleUpdateMainChartMaps;
-    private hasChartDataChanged;
-    private hasMainChartIndicatorChanged;
-    private initStaticMark;
-    private updateStaticMark;
-    private swtichMainChartType;
-    setCursorType: (cursorType: CursorType) => void;
-    private initializeMainChartIndicators;
-    private updateAllMainChartIndicatorData;
-    private updateMainChartIndicators;
-    private updateSelectedMainChartIndicators;
-    private handleOpenIndicatorSettings;
-    private handleMainChartIndicatorsSettingConfirm;
-    private handleRemoveIndicator;
-    setMockKLineMarkMode: () => void;
-    private initializeGraphManager;
-    private initializeGraphManagerProps;
-    private destroyGraphManager;
-    showAllMark: () => void;
-    hideAllMark: () => void;
-    clearAllMark: () => void;
-    setSchiffPitchforkMode: () => void;
-    setHeatMapMode: () => void;
-    setTextEditMarkMode: () => void;
-    setBubbleBoxMarkMode: () => void;
-    setPinMarkMode: () => void;
-    setEmojiMarkMode: (emoji: string) => void;
-    setSignpostMarkMode: () => void;
-    setPriceNoteMarkMode: () => void;
-    setFlagMarkMode: () => void;
-    setPriceLabelMode: () => void;
-    setShortPositionMarkMode: () => void;
-    setLongPositionMarkMode: () => void;
-    setThickArrowLineMode: () => void;
-    setEraserMode: () => void;
-    setMarkerPenMode: () => void;
-    setBrushMode: () => void;
-    setPenMode: () => void;
-    setPencilMode: () => void;
-    setTimePriceRangeMarkMode: () => void;
-    setPriceRangeMarkMode: () => void;
-    setTimeRangeMarkMode: () => void;
-    setElliottTripleCombinationMode: () => void;
-    setElliottDoubleCombinationMode: () => void;
-    setElliottTriangleMode: () => void;
-    setElliottCorrectiveMode: () => void;
-    setElliottImpulseMode: () => void;
-    setTriangleABCDMode: () => void;
-    setABCDMode: () => void;
-    setHeadAndShouldersMode: () => void;
-    setXABCDMode: () => void;
-    setDoubleCurveMode: () => void;
-    setCurveMode: () => void;
-    setSectorMode: () => void;
-    setFibonacciExtensionBaseTimeMode: () => void;
-    setFibonacciExtensionBasePriceMode: () => void;
-    setFibonacciChannelMode: () => void;
-    setFibonacciFanMode: () => void;
-    setFibonacciWedgeMode: () => void;
-    setFibonacciSpiralMode: () => void;
-    setFibonacciCircleMode: () => void;
-    setFibonacciArcMode: () => void;
-    setFibonacciRetracementMode: () => void;
-    setFibonacciTimeZoonMode: () => void;
-    setGannRectangleMode: () => void;
-    setGannBoxMode: () => void;
-    setGannFanMode: () => void;
-    setTriangleMarkMode: () => void;
-    setEllipseMarkMode: () => void;
-    setCircleMarkMode: () => void;
-    setRectangleMarkMode: () => void;
-    setEnhancedAndrewPitchforkMode: () => void;
-    setAndrewPitchforkMode: () => void;
-    setDisjointChannelMarkMode: () => void;
-    setEquidistantChannelMarkMode: () => void;
-    setLinearRegressionChannelMode: () => void;
-    setLineSegmentMarkMode: () => void;
-    setHorizontalLineMode: () => void;
-    setVerticalLineMode: () => void;
-    setArrowLineMarkMode: () => void;
-    setParallelChannelMarkMode: () => void;
-    showGraphMarkToolBar: (drawing: MarkDrawing) => void;
-    closeGraphMarkToolBar: () => void;
-    showTableMarkToolBar: (drawing: MarkDrawing) => void;
-    closeTableMarkToolBar: () => void;
-    showTextEditMarkToolBar: (drawing: MarkDrawing, isShowGrapTool: boolean) => void;
-    closeTextMarkToolBar: () => void;
-    private setupAllContainerEvents;
-    private cleanupAllContainerEvents;
-    private setupAllDocumentEvents;
-    private cleanupAllDocumentEvents;
-    private handleMouseDown;
-    private handleMouseUp;
-    private handleMouseMove;
-    serializeDrawings(): string;
-    handleViewportShiftLeft: () => void;
-    handleViewportShiftRight: () => void;
-    handleZoomIn: () => void;
-    handleZoomOut: () => void;
-    openIndicatorsModal: () => void;
-    private handleToggleIndicator;
-    private renderChartInfo;
-    private handleIndicatorsClose;
-    setImageMarkMode: () => void;
-    private handleImageConfirm;
-    private handleImageUploadClose;
-    private setSelectedImageUrl;
-    private handleChangeTextMarkFontColor;
-    private handleChangeTextMarkStyle;
-    private handleChangeTextMarkFontSize;
-    private handleChangeTextMarkGraphColor;
-    private handleChangeTextMarkGraphLineStyle;
-    private handleChangeTextMarkGraphLineWidth;
-    private handleDeleteTextEditMark;
-    private handleTextMarkEditorSave;
-    private handleTextMarkEditorCancel;
-    private handleDeleteGraphMark;
-    private handleChangeGraphMarkColor;
-    private handleChangeGraphMarkStyle;
-    private handleChangeGraphMarkWidth;
-    private handleGraphToolbarDrag;
-    private handleKeyDown;
-    private setupCanvas;
-    private handleDocumentMouseUp;
-    private handleDocumentMouseDown;
-    private handleDocumentMouseMove;
-    private handleDocumentMouseWheel;
-    getDrawingLayerElementsPosition(): Array<{
-        id: string;
-        type: string;
-        position: {
-            x: number;
-            y: number;
-        };
-        element?: HTMLElement;
-    }>;
-    setDrawingLayerElementsPosition(positions: Array<{
-        id: string;
-        type: string;
-        position: {
-            x: number;
-            y: number;
-        };
-    }>): void;
-    moveDrawingLayerElements(deltaX: number, deltaY: number): void;
-    getDrawingLayerElementsByType(type: 'text' | 'emoji'): Array<{
-        id: string;
-        position: {
-            x: number;
-            y: number;
-        };
-        element: HTMLElement;
-    }>;
-    private handleTextMarkToolBarDrag;
-    private getToolName;
-    private toggleOHLCVisibility;
-    disableChartMovement(): void;
-    enableChartMovement(): void;
-    private renderMainChart;
-    showSubChartSettingModal: (initialParams: IIndicatorInfo[] | undefined, subChartIndicatorType: SubChartIndicatorType) => void;
-    private handleSubChartSettingClose;
-    private handleSubChartSettingConfirm;
-    render(): import("react/jsx-runtime").JSX.Element;
-}
-export { ChartLayer };
-export type { MarkDrawing };

package/dist/components/CandleView/DataAdapter.d.ts

@@ -1,28 +0,0 @@
-import { I18n } from './I18n';
-import { ICandleViewDataPoint, TimeframeEnum, TimezoneEnum } from './types';
-export interface TimeframeConfig {
-    seconds: number;
-    groupBy: 'second' | 'minute' | 'hour' | 'day' | 'week' | 'month';
-}
-export interface TimeConfig {
-    timeframe?: TimeframeEnum;
-    timezone?: TimezoneEnum;
-}
-export declare const TIMEFRAME_CONFIGS: {
-    [key: string]: TimeframeConfig;
-};
-export declare function getTimeframeDisplayName(timeframe: string, i18n: I18n): string;
-export declare function generateExtendedVirtualData(originalData: ICandleViewDataPoint[], beforeCount: number, afterCount: number, timeframe?: string): ICandleViewDataPoint[];
-export declare function convertTimeZone(data: ICandleViewDataPoint[], timezone: TimezoneEnum): ICandleViewDataPoint[];
-export interface TimeZoneConfig {
-    name: string;
-    offset: string;
-    displayName: string;
-}
-export declare const TIMEZONE_CONFIGS: {
-    [key in TimezoneEnum]: TimeZoneConfig;
-};
-export declare function aggregateForTimeFrame(data: ICandleViewDataPoint[], timeframe: TimeframeEnum): ICandleViewDataPoint[];
-export declare function getTimeframeSeconds(timeframe: TimeframeEnum): number;
-export declare function createAggregatedCandle(group: ICandleViewDataPoint[]): ICandleViewDataPoint;
-export declare function fillMissingCandleTimeframe(timeframe: TimeframeEnum, data: ICandleViewDataPoint[]): ICandleViewDataPoint[];

package/dist/components/CandleView/DataLoader.d.ts

@@ -1,15 +0,0 @@
-import { ICandleViewDataPoint } from './types';
-export interface DataLoaderConfig {
-    jsonFilePath?: string;
-    data?: ICandleViewDataPoint[];
-    url?: string;
-}
-export declare class DataLoader {
-    static loadData(config: DataLoaderConfig): ICandleViewDataPoint[];
-    private static loadFromLocalFile;
-    private static loadFromUrl;
-    private static parseOHLCData;
-    private static validateAndFormatData;
-    static validateConfig(config: DataLoaderConfig): boolean;
-    static getActiveDataSource(config: DataLoaderConfig): string;
-}

package/dist/components/CandleView/DataManager.d.ts

@@ -1,23 +0,0 @@
-import { ICandleViewDataPoint, MainChartType, TimeframeEnum, TimezoneEnum } from './types';
-import { TimeConfig } from './DataAdapter';
-export interface DataProcessingConfig {
-    timeframe: TimeframeEnum;
-    timezone: TimezoneEnum;
-    shouldExtendVirtualData?: boolean;
-    virtualDataBeforeCount?: number;
-    virtualDataAfterCount?: number;
-    chartType?: string;
-}
-export declare function buildDefaultDataProcessingConfig(timeConfig: TimeConfig, chartType: MainChartType, virtualDataBeforeCount?: number, virtualDataAfterCount?: number): DataProcessingConfig;
-export declare class DataManager {
-    static handleData(originalData: ICandleViewDataPoint[], config: DataProcessingConfig, chartType: MainChartType): ICandleViewDataPoint[];
-    private static extendWithVirtualData;
-    private static calculateOptimalVirtualDataCount;
-    private static formatCache;
-    static handleChartDisplayData(data: ICandleViewDataPoint[], mainChartType: MainChartType): ICandleViewDataPoint[];
-    static filterRealData(data: ICandleViewDataPoint[]): ICandleViewDataPoint[];
-    static getTimeframeConfig(timeframe: TimeframeEnum): import('./DataAdapter').TimeframeConfig;
-    static validateData(data: ICandleViewDataPoint[]): boolean;
-    static sampleData(data: ICandleViewDataPoint[], sampleRate?: number): ICandleViewDataPoint[];
-}
-export declare const processChartData: (originalData: ICandleViewDataPoint[], config: DataProcessingConfig, chartType: MainChartType) => ICandleViewDataPoint[];

package/dist/components/CandleView/DataPointManager.d.ts

@@ -1,45 +0,0 @@
-import { ICandleViewDataPoint } from './types';
-export declare class DataPointManager {
-    private static lastFirstRealDataInViewport;
-    private static lastLastRealDataInViewport;
-    private static lastFirstRealDataLeftViewport;
-    private static lastFirstRealDataRightViewport;
-    private static lastLastRealDataLeftViewport;
-    private static lastLastRealDataRightViewport;
-    private static lastFirstRealDataNearRightViewport;
-    private static lastLastRealDataNearLeftViewport;
-    static getRealDataRange(data: ICandleViewDataPoint[]): {
-        firstIndex: number;
-        lastIndex: number;
-    } | null;
-    static checkDataPointPositions(visibleLogicalRange: {
-        from: number;
-        to: number;
-    } | null, realDataRange: {
-        firstIndex: number;
-        lastIndex: number;
-    } | null, callbacks: {
-        onFirstRealDataExitLeftViewport?: () => void;
-        onFirstRealDataExitRightViewport?: () => void;
-        onLastRealDataExitLeftViewport?: () => void;
-        onLastRealDataExitRightViewport?: () => void;
-        onFirstRealDataExitViewport?: () => void;
-        onLastRealDataExitViewport?: () => void;
-        onFirstRealDataEnterLeftViewport?: () => void;
-        onFirstRealDataNearRightViewport?: () => void;
-        onLastRealDataNearLeftViewport?: () => void;
-        onFirstRealDataLeaveNearRightViewport?: () => void;
-        onLastRealDataLeaveNearLeftViewport?: () => void;
-    }): void;
-    static reset(): void;
-    static getCurrentState(): {
-        lastFirstRealDataInViewport: boolean;
-        lastLastRealDataInViewport: boolean;
-        lastFirstRealDataLeftViewport: boolean;
-        lastFirstRealDataRightViewport: boolean;
-        lastLastRealDataLeftViewport: boolean;
-        lastLastRealDataRightViewport: boolean;
-        lastFirstRealDataNearRightViewport: boolean;
-        lastLastRealDataNearLeftViewport: boolean;
-    };
-}