@pradeepjadhav/trading-reload-chart 1.0.0

package/dist/canvas/layers/ShapesLayer/FibRetracementShape.d.ts

@@ -0,0 +1,28 @@
+import { FibRetracementConfig, FibRetracementShapeData, ShapeCoordinateConverter, ShapeHandleHitbox, ShapePoint, ShapeVertex } from './ShapesLayer.types';
+export declare class FibRetracementShape {
+    static defaultConfig: FibRetracementConfig;
+    static draw({ ctx, shape, converter, config, selected, hovered, }: {
+        ctx: CanvasRenderingContext2D;
+        shape: FibRetracementShapeData;
+        converter: ShapeCoordinateConverter;
+        config?: FibRetracementConfig;
+        selected?: boolean;
+        hovered?: boolean;
+    }): void;
+    static drawDraft({ ctx, vertices, converter, config, }: {
+        ctx: CanvasRenderingContext2D;
+        vertices: [ShapeVertex, ShapeVertex];
+        converter: ShapeCoordinateConverter;
+        config?: FibRetracementConfig;
+    }): void;
+    static getHandles(shape: FibRetracementShapeData, converter: ShapeCoordinateConverter, config?: FibRetracementConfig): ShapeHandleHitbox[];
+    static hitTest({ point, shape, converter, tolerance, config, }: {
+        point: ShapePoint;
+        shape: FibRetracementShapeData;
+        converter: ShapeCoordinateConverter;
+        tolerance?: number;
+        config?: FibRetracementConfig;
+    }): boolean;
+    static move(shape: FibRetracementShapeData, delta: ShapeVertex): FibRetracementShapeData;
+    static resize(shape: FibRetracementShapeData, handleType: ShapeHandleHitbox["type"], vertex: ShapeVertex): FibRetracementShapeData;
+}

package/dist/canvas/layers/ShapesLayer/LineShape.d.ts

@@ -0,0 +1,27 @@
+import { ShapeCoordinateConverter, CommonShapeConfig, ShapeHandleHitbox, ShapePoint, ShapeVertex, TrendlineShape } from './ShapesLayer.types';
+export declare class LineShape {
+    static defaultConfig: CommonShapeConfig;
+    static draw({ ctx, shape, converter, config, selected, hovered, }: {
+        ctx: CanvasRenderingContext2D;
+        shape: TrendlineShape;
+        converter: ShapeCoordinateConverter;
+        config?: CommonShapeConfig;
+        selected?: boolean;
+        hovered?: boolean;
+    }): void;
+    static drawDraft({ ctx, vertices, converter, config, }: {
+        ctx: CanvasRenderingContext2D;
+        vertices: [ShapeVertex, ShapeVertex];
+        converter: ShapeCoordinateConverter;
+        config?: CommonShapeConfig;
+    }): void;
+    static getHandles(shape: TrendlineShape, converter: ShapeCoordinateConverter, config?: CommonShapeConfig): ShapeHandleHitbox[];
+    static hitTest({ point, shape, converter, tolerance, }: {
+        point: ShapePoint;
+        shape: TrendlineShape;
+        converter: ShapeCoordinateConverter;
+        tolerance?: number;
+    }): boolean;
+    static move(shape: TrendlineShape, delta: ShapeVertex): TrendlineShape;
+    static resize(shape: TrendlineShape, handleType: ShapeHandleHitbox["type"], vertex: ShapeVertex): TrendlineShape;
+}

package/dist/canvas/layers/ShapesLayer/PathShape.d.ts

@@ -0,0 +1,29 @@
+import { PathShapeData, ShapeCoordinateConverter, CommonShapeConfig, ShapeHandleHitbox, ShapePoint, ShapeVertex } from './ShapesLayer.types';
+export declare class PathShape {
+    static defaultConfig: CommonShapeConfig;
+    static draw({ ctx, shape, converter, config, selected, hovered, }: {
+        ctx: CanvasRenderingContext2D;
+        shape: PathShapeData;
+        converter: ShapeCoordinateConverter;
+        config?: CommonShapeConfig;
+        selected?: boolean;
+        hovered?: boolean;
+    }): void;
+    static drawDraft({ ctx, vertices, previewVertex, converter, config, }: {
+        ctx: CanvasRenderingContext2D;
+        vertices: ShapeVertex[];
+        previewVertex: ShapeVertex | null;
+        converter: ShapeCoordinateConverter;
+        config?: CommonShapeConfig;
+    }): void;
+    static getHandles(shape: PathShapeData, converter: ShapeCoordinateConverter, config?: CommonShapeConfig): ShapeHandleHitbox[];
+    static hitTest({ point, shape, converter, tolerance, }: {
+        point: ShapePoint;
+        shape: PathShapeData;
+        converter: ShapeCoordinateConverter;
+        tolerance?: number;
+    }): boolean;
+    static move(shape: PathShapeData, delta: ShapeVertex): PathShapeData;
+    static resize(shape: PathShapeData, handleIndex: number, vertex: ShapeVertex): PathShapeData;
+    private static drawEndArrow;
+}

package/dist/canvas/layers/ShapesLayer/RectangleShape.d.ts

@@ -0,0 +1,28 @@
+import { RectangleShapeData, ShapeCoordinateConverter, ShapeHandleHitbox, ShapePoint, ShapeVertex, RectangleShapeConfig } from './ShapesLayer.types';
+export declare class RectangleShape {
+    static defaultConfig: RectangleShapeConfig;
+    static draw({ ctx, shape, converter, config, selected, hovered, }: {
+        ctx: CanvasRenderingContext2D;
+        shape: RectangleShapeData;
+        converter: ShapeCoordinateConverter;
+        config?: RectangleShapeConfig;
+        selected?: boolean;
+        hovered?: boolean;
+    }): void;
+    static drawDraft({ ctx, vertices, converter, config, }: {
+        ctx: CanvasRenderingContext2D;
+        vertices: [ShapeVertex, ShapeVertex];
+        converter: ShapeCoordinateConverter;
+        config?: RectangleShapeConfig;
+    }): void;
+    static getHandles(shape: RectangleShapeData, converter: ShapeCoordinateConverter, config?: RectangleShapeConfig): ShapeHandleHitbox[];
+    static hitTest({ point, shape, converter, tolerance, }: {
+        point: ShapePoint;
+        shape: RectangleShapeData;
+        converter: ShapeCoordinateConverter;
+        tolerance?: number;
+    }): boolean;
+    static move(shape: RectangleShapeData, delta: ShapeVertex): RectangleShapeData;
+    static resize(shape: RectangleShapeData, handleType: ShapeHandleHitbox["type"], vertex: ShapeVertex): RectangleShapeData;
+    private static drawText;
+}

package/dist/canvas/layers/ShapesLayer/ShapesLayer.d.ts

@@ -0,0 +1,70 @@
+import { Candle } from '../../../models/Candle.types';
+import { ChartViewport } from '../../../models/ChartViewport.types';
+import { PartialShapeConfig, Shape, ShapeConfig, ShapeHandleHitbox, ShapesLayerOptions, ShapeToolType } from './ShapesLayer.types';
+export declare class ShapesLayer {
+    canvas: HTMLCanvasElement;
+    ctx: CanvasRenderingContext2D;
+    activeSymbol: string;
+    candles: Candle[];
+    viewport: ChartViewport | null;
+    shapes: Shape[];
+    activeTool: ShapeToolType | null;
+    config: ShapeConfig;
+    selectedShapeId: string | null;
+    hoveredShapeId: string | null;
+    handleHitboxes: ShapeHandleHitbox[];
+    private draft;
+    private dragState;
+    private onShapeAdded?;
+    private onShapeModified?;
+    private onShapeSelected?;
+    private onToolChange?;
+    constructor(options: ShapesLayerOptions);
+    setCandles(candles: Candle[]): void;
+    setViewport(viewport: ChartViewport): void;
+    setShapes(shapes: Shape[]): void;
+    setConfig(config?: PartialShapeConfig): void;
+    setActiveTool(tool: ShapeToolType | null): void;
+    clearHoverState(): void;
+    render(): void;
+    handlePointerEvent(event: PointerEvent | MouseEvent): boolean;
+    handleKeyboardEvent(event: KeyboardEvent): boolean;
+    private handlePointerDown;
+    private handlePointerMove;
+    private handlePointerUp;
+    private handleContextMenu;
+    private handleToolPointerDown;
+    private handleTwoPointDraft;
+    private handlePathDraft;
+    private completePathDraft;
+    private addPositionShape;
+    private updateDraftPreview;
+    private addShape;
+    private emitShapeModified;
+    private applyDrag;
+    private moveShape;
+    private resizeShape;
+    private drawShape;
+    private drawDraft;
+    private rebuildHandleHitboxes;
+    private getShapeHandles;
+    private findHandleAtPoint;
+    private findHandleAtPointForShape;
+    private findShapeAtPoint;
+    private isShapeHit;
+    private setSelectedShapeId;
+    private createShapeSelectedPayload;
+    private getTrendlineConfig;
+    private getRectangleConfig;
+    private getPathConfig;
+    private getFibRetracementConfig;
+    private getPositionConfig;
+    private setActiveToolAndEmit;
+    private getConverter;
+    private getXForTime;
+    private getTimeForX;
+    private getYForPrice;
+    private getPriceForY;
+    private getCandleStepWidth;
+    private mergeConfig;
+}

package/dist/canvas/layers/ShapesLayer/ShapesLayer.helpers.d.ts

@@ -0,0 +1,47 @@
+import { Candle } from '../../../models/Candle.types';
+import { FibLevelValue, Shape, ShapeBoundingBox, ShapeCoordinateConverter, CommonShapeConfig, ShapeHandleHitbox, ShapeLineStyle, ShapePoint, ShapeVertex } from './ShapesLayer.types';
+export declare const SHAPE_HIT_TOLERANCE = 8;
+export declare const SHAPE_HANDLE_RADIUS = 5;
+export declare const generateShapeId: () => string;
+export declare const getCanvasPoint: (canvas: HTMLCanvasElement, event: PointerEvent | MouseEvent) => ShapePoint;
+export declare const createVertexFromPoint: (point: ShapePoint, converter: ShapeCoordinateConverter) => ShapeVertex;
+export declare const vertexToPoint: (vertex: ShapeVertex, converter: ShapeCoordinateConverter) => ShapePoint;
+export declare const getBoundingBoxFromPoints: (pointA: ShapePoint, pointB: ShapePoint) => ShapeBoundingBox;
+export declare const getBoundingBoxFromVertices: (vertexA: ShapeVertex, vertexB: ShapeVertex, converter: ShapeCoordinateConverter) => ShapeBoundingBox;
+export declare const getBoundingBoxFromShape: (shape: Shape, converter: ShapeCoordinateConverter) => ShapeBoundingBox;
+export declare const getDistance: (pointA: ShapePoint, pointB: ShapePoint) => number;
+export declare const getDistanceToLineSegment: (point: ShapePoint, lineStart: ShapePoint, lineEnd: ShapePoint) => number;
+export declare const isPointInsideBoundingBox: (point: ShapePoint, box: ShapeBoundingBox, padding?: number) => boolean;
+export declare const isPointNearBoundingBoxBorder: (point: ShapePoint, box: ShapeBoundingBox, tolerance?: number) => boolean;
+export declare const createHandleHitbox: ({ shapeId, type, point, radius, cursor, index, }: {
+    shapeId: string;
+    type: ShapeHandleHitbox["type"];
+    point: ShapePoint;
+    radius?: number;
+    cursor?: string;
+    index?: number;
+}) => ShapeHandleHitbox;
+export declare const isPointInsideHandle: (point: ShapePoint, handle: ShapeHandleHitbox) => boolean;
+export declare const getLineDash: (lineStyle: ShapeLineStyle, lineWidth?: number) => number[];
+export declare const applyStrokeStyle: (ctx: CanvasRenderingContext2D, style: Pick<CommonShapeConfig, "lineColor" | "lineOpacity" | "lineWidth" | "lineStyle">, lineWidthOverride?: number) => void;
+export declare const applyFillStyle: (ctx: CanvasRenderingContext2D, fillColor: string | undefined, fillOpacity: number | undefined) => boolean;
+export declare const resetCanvasLineDash: (ctx: CanvasRenderingContext2D) => void;
+export declare const drawHandle: (ctx: CanvasRenderingContext2D, handle: ShapeHandleHitbox, options?: {
+    fillColor: string;
+    borderColor: string;
+    borderThickness: number;
+}) => void;
+export declare const drawHandles: (ctx: CanvasRenderingContext2D, handles: ShapeHandleHitbox[], options?: {
+    fillColor: string;
+    borderColor: string;
+    borderThickness: number;
+}) => void;
+export declare const withOpacity: (color: string, opacity: number) => string;
+export declare const hexToRgba: (hex: string, opacity: number) => string;
+export declare const clamp: (value: number, min: number, max: number) => number;
+export declare const getFibLevelPrice: (startPrice: number, endPrice: number, level: FibLevelValue) => number;
+export declare const getNearestCandleIndexByTime: (candles: Candle[], time: number) => number;
+export declare const getAverageCandleTimeStep: (candles: Candle[]) => number;
+export declare const getFutureCandleTime: (candles: Candle[], startTime: number, candleCount: number) => number;
+export declare const getCursorForHandle: (handleType: ShapeHandleHitbox["type"]) => string;
+export declare const hasPrimaryButton: (event: PointerEvent | MouseEvent) => boolean;