@forgecharts/sdk 1.1.23 → 1.1.28

package/dist/core/InteractionManager.js

@@ -0,0 +1,698 @@
+// ─── Constants ────────────────────────────────────────────────────────────────
+/** Tolerated pixel distance for drawing hit detection. */
+const DRAWING_HIT_PX = 6;
+/** Tolerated pixel distance for handle hit detection. */
+const HANDLE_HIT_PX = 8;
+// ─── InteractionManager ───────────────────────────────────────────────────────
+/**
+ * InteractionManager — the single owner of all DOM input events for a chart.
+ *
+ * Responsibilities:
+ * - Mouse: pan (left-drag), crosshair tracking, click detection
+ * - Wheel: zoom
+ * - Right-click: contextmenu routing
+ * - Keyboard: arrow-key pan, +/- zoom, Esc / Delete shortcuts
+ * - Hit-testing: drawings → bars → axis zones
+ * - Selection state: tracks the currently selected drawing id
+ *
+ * Usage:
+ * ```ts
+ * const interaction = new InteractionManager(
+ *   canvasElement,
+ *   chart.transform(),
+ *   {
+ *     onPan: (dx, dy) => { transform.pan(dx, dy); markDirty(); },
+ *     onZoom: (f, ox)  => { transform.zoomTime(f, ox); markDirty(); },
+ *     onCrosshairMove: (x, y) => { crosshair.update(x, y); markDirty(); },
+ *     onCrosshairHide: ()     => { crosshair.hide(); markDirty(); },
+ *     onContextMenu: (x, y, hit) => showMenu(x, y, hit),
+ *     onKeyAction: (action)   => handleKey(action),
+ *   },
+ * );
+ *
+ * // Call on chart resize:
+ * interaction.setTransform(chart.transform());
+ *
+ * // Feed visible bars for bar-snap hit-testing:
+ * interaction.setBars(series.data());
+ *
+ * // Feed drawings for drawing hit-testing:
+ * interaction.setDrawings(drawingManager.all());
+ *
+ * // Teardown:
+ * interaction.destroy();
+ * ```
+ */
+export class InteractionManager {
+    _el;
+    _transform;
+    _handlers;
+    _opts;
+    // ── Hit-test data feeds ───────────────────────────────────────────────────
+    _drawings = [];
+    _bars = [];
+    // ── Mouse state ───────────────────────────────────────────────────────────
+    _isDragging = false;
+    _dragStartX = 0;
+    _dragStartY = 0;
+    _lastDragX = 0;
+    _lastDragY = 0;
+    /** True once the pointer has moved past `clickThreshold` during a drag. */
+    _hasMoved = false;
+    /** True while the user is dragging on the price axis strip. */
+    _priceAxisDragging = false;
+    // ── Selection state ───────────────────────────────────────────────────────
+    _selectedDrawingId = null;
+    // ── Drawing tool state ────────────────────────────────────────────────────
+    _drawingMode = false;
+    /** True when the native cursor should be hidden (crosshair / dot / demonstration). */
+    _hideCursor = false;
+    /** Sets cursor style, respecting _hideCursor — 'none' always wins when hiding. */
+    _setCursor(style) {
+        this._el.style.cursor = this._hideCursor ? 'none' : style;
+    }
+    /** Set when a drawing is committed mid-mousedown; prevents the paired mouseup from auto-selecting it. */
+    _suppressNextClick = false;
+    _handleDragId = null;
+    _handleDragIdx = -1;
+    _bodyMoveId = null;
+    _bodyMovePrevX = 0;
+    _bodyMovePrevY = 0;
+    constructor(element, transform, handlers, options = {}) {
+        this._el = element;
+        this._transform = transform;
+        this._handlers = handlers;
+        this._opts = {
+            enablePan: options.enablePan ?? true,
+            enableZoom: options.enableZoom ?? true,
+            clickThreshold: options.clickThreshold ?? 4,
+            zoomStep: options.zoomStep ?? 1.1,
+            keyPanStep: options.keyPanStep ?? 40,
+            keyZoomStep: options.keyZoomStep ?? 1.1,
+        };
+        // Make container keyboard-focusable so `keydown` fires on it
+        if (element.tabIndex < 0)
+            element.tabIndex = 0;
+        element.style.outline = 'none'; // suppress browser focus ring
+        this._attach();
+    }
+    // ─── Data feeds (call after every data / drawing change) ──────────────────
+    /** Swap the transform reference after a resize. */
+    setTransform(transform) {
+        this._transform = transform;
+    }
+    /** Provide the current drawing list for hit-testing. */
+    setDrawings(drawings) {
+        this._drawings = drawings;
+    }
+    /**
+     * Provide the visible bars for bar-snap hit-testing on the primary series.
+     * Passing `series.data()` is fine; the manager filters by visible range.
+     */
+    setBars(bars) {
+        this._bars = bars;
+    }
+    // ─── Selection ────────────────────────────────────────────────────────────
+    /** Id of the currently selected drawing, or `null`. */
+    get selectedDrawingId() {
+        return this._selectedDrawingId;
+    }
+    /** Programmatically deselect (e.g. on symbol / timeframe change). */
+    clearSelection() {
+        this._selectedDrawingId = null;
+    }
+    /**
+     * Switches between drawing-tool mode (crosshair cursor, click fires onDrawClick)
+     * and normal cursor mode.  Also resets any in-progress drag state.
+     */
+    /** Hides (`true`) or shows (`false`) the native OS cursor. Used by crosshair, dot, and demonstration modes. */
+    setHideCursor(hidden) {
+        this._hideCursor = hidden;
+        if (!this._drawingMode) {
+            this._el.style.cursor = hidden ? 'none' : 'default';
+        }
+    }
+    setDrawingMode(active) {
+        if (this._drawingMode && !active) {
+            // Drawing was committed during a mousedown — suppress the paired mouseup click
+            // so it doesn't immediately auto-select the newly placed drawing.
+            this._suppressNextClick = true;
+        }
+        this._drawingMode = active;
+        this._el.style.cursor = active ? 'crosshair' : (this._hideCursor ? 'none' : 'default');
+        this._isDragging = false;
+        this._hasMoved = false;
+        this._handleDragId = null;
+        this._handleDragIdx = -1;
+        this._bodyMoveId = null;
+    }
+    // ─── Lifecycle ────────────────────────────────────────────────────────────
+    /** Removes all DOM event listeners. Must be called in the chart's `destroy()`. */
+    destroy() {
+        this._detach();
+    }
+    // ─── DOM listener registry ────────────────────────────────────────────────
+    _attach() {
+        const el = this._el;
+        // Mouse — always registered so crosshair works even with pan disabled
+        el.addEventListener('mousedown', this._onMouseDown);
+        el.addEventListener('mousemove', this._onMouseMove);
+        el.addEventListener('mouseup', this._onMouseUp);
+        el.addEventListener('mouseleave', this._onMouseLeave);
+        if (this._opts.enableZoom) {
+            el.addEventListener('wheel', this._onWheel, { passive: false });
+        }
+        el.addEventListener('contextmenu', this._onContextMenu);
+        el.addEventListener('keydown', this._onKeyDown);
+        el.addEventListener('dblclick', this._onDblClick);
+    }
+    _detach() {
+        const el = this._el;
+        el.removeEventListener('mousedown', this._onMouseDown);
+        el.removeEventListener('mousemove', this._onMouseMove);
+        el.removeEventListener('mouseup', this._onMouseUp);
+        el.removeEventListener('mouseleave', this._onMouseLeave);
+        el.removeEventListener('wheel', this._onWheel);
+        el.removeEventListener('contextmenu', this._onContextMenu);
+        el.removeEventListener('keydown', this._onKeyDown);
+        el.removeEventListener('dblclick', this._onDblClick);
+    }
+    // ─── Mouse handlers ───────────────────────────────────────────────────────
+    _onMouseDown = (e) => {
+        if (e.button !== 0)
+            return; // left button only
+        this._el.focus({ preventScroll: true });
+        const x = e.offsetX;
+        const y = e.offsetY;
+        // Drawing tool mode: route click to drawing placement
+        if (this._drawingMode) {
+            this._handlers.onDrawClick?.(x, y);
+            return;
+        }
+        // Cursor mode: check handles of the selected drawing first (highest priority)
+        if (this._selectedDrawingId !== null) {
+            for (const drawing of this._drawings) {
+                if (drawing.id !== this._selectedDrawingId || drawing.visible === false)
+                    continue;
+                const hi = this._hitTestHandles(x, y, drawing);
+                if (hi >= 0) {
+                    this._handleDragId = drawing.id;
+                    this._handleDragIdx = hi;
+                    this._setCursor('grabbing');
+                    this._handlers.onHandleDragStart?.(drawing.id, hi);
+                    return;
+                }
+                break; // handles checked — move on
+            }
+        }
+        // Auto-select + immediately start body drag on ANY hovered drawing.
+        // This means one mousedown is all that's needed — no separate
+        // "click to select, then click+drag" two-step required.
+        const drawingBodyHit = this._hitTestDrawings(x, y);
+        if (drawingBodyHit !== null) {
+            this._selectedDrawingId = drawingBodyHit.id;
+            this._bodyMoveId = drawingBodyHit.id;
+            this._bodyMovePrevX = x;
+            this._bodyMovePrevY = y;
+            this._setCursor('grabbing');
+            this._handlers.onBodyMoveStart?.(drawingBodyHit.id);
+            return;
+        }
+        // Price axis — start vertical drag to stretch/compress price scale
+        if (x >= this._transform.plotWidth && y < this._transform.plotHeight) {
+            this._priceAxisDragging = true;
+            this._lastDragY = y;
+            this._setCursor('ns-resize');
+            return;
+        }
+        // Normal pan
+        this._isDragging = true;
+        this._hasMoved = false;
+        this._dragStartX = x;
+        this._dragStartY = y;
+        this._lastDragX = x;
+        this._lastDragY = y;
+    };
+    _onMouseMove = (e) => {
+        const x = e.offsetX;
+        const y = e.offsetY;
+        // Drawing-tool preview
+        if (this._drawingMode) {
+            this._handlers.onDrawPointerMove?.(x, y);
+            this._handlers.onCrosshairMove?.(x, y, this._hitTest(x, y));
+            return;
+        }
+        // Handle drag
+        if (this._handleDragId !== null) {
+            this._setCursor('grabbing');
+            this._handlers.onHandleDragMove?.(this._handleDragId, this._handleDragIdx, x, y);
+            return;
+        }
+        // Body move
+        if (this._bodyMoveId !== null) {
+            const dx = x - this._bodyMovePrevX;
+            const dy = y - this._bodyMovePrevY;
+            this._bodyMovePrevX = x;
+            this._bodyMovePrevY = y;
+            this._setCursor('grabbing');
+            this._handlers.onBodyMoveMove?.(this._bodyMoveId, dx, dy);
+            return;
+        }
+        // Price axis drag — zoom price scale vertically
+        if (this._priceAxisDragging) {
+            const dy = y - this._lastDragY;
+            this._lastDragY = y;
+            if (dy !== 0)
+                this._handlers.onPriceAxisDrag?.(dy);
+            this._setCursor('ns-resize');
+            return;
+        }
+        if (this._isDragging) {
+            const dx = x - this._lastDragX;
+            const dy = y - this._lastDragY;
+            const totalDist = Math.hypot(x - this._dragStartX, y - this._dragStartY);
+            if (totalDist > this._opts.clickThreshold) {
+                this._hasMoved = true;
+            }
+            if (this._hasMoved && this._opts.enablePan) {
+                this._handlers.onPan?.(dx, dy);
+            }
+            this._lastDragX = x;
+            this._lastDragY = y;
+        }
+        // Crosshair + cursor feedback
+        const hit = this._hitTest(x, y);
+        this._handlers.onCrosshairMove?.(x, y, hit);
+        if (!this._isDragging) {
+            if (x >= this._transform.plotWidth && y < this._transform.plotHeight) {
+                this._setCursor('ns-resize');
+            }
+            else if (hit.kind === 'drawingHandle') {
+                this._setCursor('grab');
+            }
+            else if (hit.kind === 'drawing') {
+                this._setCursor('grab');
+            }
+            else {
+                this._setCursor('default');
+            }
+        }
+    };
+    _onMouseUp = (e) => {
+        if (e.button !== 0)
+            return;
+        // Finish price axis drag
+        if (this._priceAxisDragging) {
+            this._priceAxisDragging = false;
+            this._setCursor('default');
+            return;
+        }
+        // Finish handle drag
+        if (this._handleDragId !== null) {
+            const id = this._handleDragId;
+            const idx = this._handleDragIdx;
+            this._handleDragId = null;
+            this._handleDragIdx = -1;
+            this._setCursor('grab');
+            this._handlers.onHandleDragEnd?.(id, idx);
+            return;
+        }
+        // Finish body move
+        if (this._bodyMoveId !== null) {
+            const id = this._bodyMoveId;
+            this._bodyMoveId = null;
+            this._setCursor('grab');
+            this._handlers.onBodyMoveEnd?.(id);
+            return;
+        }
+        const wasClick = !this._hasMoved;
+        this._isDragging = false;
+        this._hasMoved = false;
+        if (wasClick) {
+            if (this._suppressNextClick) {
+                this._suppressNextClick = false;
+            }
+            else {
+                const x = e.offsetX;
+                const y = e.offsetY;
+                const hit = this._hitTest(x, y);
+                this._handleClick(x, y, hit);
+            }
+        }
+    };
+    _onMouseLeave = () => {
+        this._isDragging = false;
+        this._hasMoved = false;
+        this._priceAxisDragging = false;
+        this._handleDragId = null;
+        this._handleDragIdx = -1;
+        this._bodyMoveId = null;
+        this._handlers.onCrosshairHide?.();
+    };
+    // ─── Wheel / zoom ─────────────────────────────────────────────────────────
+    _onWheel = (e) => {
+        e.preventDefault();
+        const x = e.offsetX;
+        const y = e.offsetY;
+        const plotW = this._transform.plotWidth;
+        const plotH = this._transform.plotHeight;
+        // Proportional zoom: normalise deltaY against one standard notch (120 px).
+        // High-resolution trackpads send many small deltas; mice send 120 at a time.
+        // Range: 0.8% per tiny trackpad nudge → 4% per full mouse-wheel notch.
+        // This keeps one notch feeling gentle while fast spinning still zooms quickly.
+        const rawAbs = Math.abs(e.deltaY);
+        const speed = Math.min(rawAbs / 120, 1); // 0–1; 1 = one standard notch
+        const magnitude = 0.008 + speed * 0.032; // 0.8% minimum → 4% per notch
+        const baseZoom = 1 + magnitude;
+        const factor = e.deltaY > 0 ? baseZoom : 1 / baseZoom;
+        // Price axis strip (right side) — zoom price scale
+        if (x >= plotW && y < plotH) {
+            this._handlers.onPriceScaleZoom?.(factor, y);
+            return;
+        }
+        // Time axis strip (bottom) — zoom time scale (expand/contract left-right)
+        if (y >= plotH) {
+            // Zoom around the horizontal centre of the plot so the chart expands
+            // and contracts symmetrically rather than anchored to the cursor.
+            this._handlers.onZoom?.(factor, plotW / 2);
+            return;
+        }
+        // Chart plot area — zoom time axis
+        this._handlers.onZoom?.(factor, x);
+    };
+    // ─── Double-click — price axis fit ──────────────────────────────────────
+    _onDblClick = (e) => {
+        // Fire onFitContent when the double-click lands on the price axis (right)
+        // or the time axis (bottom) — both reset to the default viewport.
+        const onPriceAxis = e.offsetX >= this._transform.plotWidth;
+        const onTimeAxis = e.offsetY >= this._transform.plotHeight;
+        if (onPriceAxis || onTimeAxis) {
+            e.preventDefault();
+            this._handlers.onFitContent?.();
+        }
+    };
+    // ─── Context menu ─────────────────────────────────────────────────────────
+    _onContextMenu = (e) => {
+        e.preventDefault();
+        const x = e.offsetX;
+        const y = e.offsetY;
+        const hit = this._hitTest(x, y);
+        this._handlers.onContextMenu?.(x, y, hit);
+    };
+    // ─── Keyboard ─────────────────────────────────────────────────────────────
+    _onKeyDown = (e) => {
+        const action = this._keyToAction(e.key);
+        if (action === null)
+            return;
+        // Suppress browser scroll / zoom for chart keys
+        e.preventDefault();
+        const modifiers = {
+            shift: e.shiftKey,
+            ctrl: e.ctrlKey,
+            alt: e.altKey,
+            meta: e.metaKey,
+        };
+        this._handlers.onKeyAction?.(action, modifiers);
+    };
+    _keyToAction(key) {
+        switch (key) {
+            case 'ArrowLeft': return 'panLeft';
+            case 'ArrowRight': return 'panRight';
+            case 'ArrowUp': return 'panUp';
+            case 'ArrowDown': return 'panDown';
+            case '+':
+            case '=': return 'zoomIn';
+            case '-':
+            case '_': return 'zoomOut';
+            case 'Home': return 'scrollToStart';
+            case 'End': return 'scrollToEnd';
+            case 'Escape': return 'deselect';
+            case 'Delete':
+            case 'Backspace': return 'deleteSelection';
+            default: return null;
+        }
+    }
+    // ─── Click → selection ────────────────────────────────────────────────────
+    _handleClick(x, y, hit) {
+        if (hit.kind === 'drawing') {
+            this._selectedDrawingId = hit.id;
+            this._handlers.onSelect?.(x, y, hit);
+        }
+        else if (hit.kind === 'bar') {
+            this._selectedDrawingId = null;
+            this._handlers.onSelect?.(x, y, hit);
+        }
+        else {
+            this._selectedDrawingId = null;
+            this._handlers.onDeselect?.();
+        }
+    }
+    // ─── Hit-testing ─────────────────────────────────────────────────────────
+    _hitTest(x, y) {
+        const t = this._transform;
+        // Price axis zone (right strip)
+        if (x >= t.plotWidth) {
+            return { kind: 'priceAxis' };
+        }
+        // Time axis zone (bottom strip)
+        if (y >= t.plotHeight) {
+            return { kind: 'timeAxis' };
+        }
+        // Handles of selected drawing — highest priority
+        if (this._selectedDrawingId !== null) {
+            for (const drawing of this._drawings) {
+                if (drawing.id !== this._selectedDrawingId || drawing.visible === false)
+                    continue;
+                const hi = this._hitTestHandles(x, y, drawing);
+                if (hi >= 0) {
+                    return { kind: 'drawingHandle', id: drawing.id, type: drawing.type, handleIndex: hi };
+                }
+            }
+        }
+        // Drawings — higher priority than bars
+        const drawingHit = this._hitTestDrawings(x, y);
+        if (drawingHit !== null) {
+            return { kind: 'drawing', id: drawingHit.id, type: drawingHit.type };
+        }
+        // Nearest visible bar
+        const barHit = this._hitTestBar(x);
+        if (barHit !== null) {
+            return { kind: 'bar', index: barHit.index, bar: barHit.bar };
+        }
+        return { kind: 'none' };
+    }
+    _hitTestHandles(x, y, drawing) {
+        const t = this._transform;
+        for (let i = 0; i < drawing.points.length; i++) {
+            const p = drawing.points[i];
+            if (Math.hypot(x - t.timeToX(p.time), y - t.priceToY(p.price)) < HANDLE_HIT_PX) {
+                return i;
+            }
+        }
+        return -1;
+    }
+    _hitTestDrawings(x, y) {
+        let bestId = null;
+        let bestType = null;
+        let bestDist = DRAWING_HIT_PX + 1;
+        for (const drawing of this._drawings) {
+            if (drawing.visible === false)
+                continue;
+            const rawDist = this._distToDrawing(x, y, drawing);
+            // Small bias for the selected drawing so it "sticks" under the cursor
+            const dist = rawDist + (drawing.id === this._selectedDrawingId ? -2 : 0);
+            if (dist < bestDist) {
+                bestDist = dist;
+                bestId = drawing.id;
+                bestType = drawing.type;
+            }
+        }
+        return bestId !== null && bestType !== null ? { id: bestId, type: bestType } : null;
+    }
+    _distToDrawing(mx, my, drawing) {
+        const t = this._transform;
+        switch (drawing.type) {
+            case 'horizontal': {
+                const p0 = drawing.points[0];
+                if (!p0)
+                    return Infinity;
+                return Math.abs(my - t.priceToY(p0.price));
+            }
+            case 'vertical': {
+                const p0 = drawing.points[0];
+                if (!p0)
+                    return Infinity;
+                return Math.abs(mx - t.timeToX(p0.time));
+            }
+            case 'trendline':
+            case 'fibRetracement': {
+                const p0 = drawing.points[0];
+                const p1 = drawing.points[1];
+                if (!p0 || !p1)
+                    return Infinity;
+                return this._distPointToSegment(mx, my, t.timeToX(p0.time), t.priceToY(p0.price), t.timeToX(p1.time), t.priceToY(p1.price));
+            }
+            case 'ray': {
+                const p0 = drawing.points[0];
+                const p1 = drawing.points[1];
+                if (!p0 || !p1)
+                    return Infinity;
+                const x0 = t.timeToX(p0.time);
+                const y0 = t.priceToY(p0.price);
+                const dx = t.timeToX(p1.time) - x0;
+                const dy = t.priceToY(p1.price) - y0;
+                // Compute exit using the same formula as the renderer
+                const pw = t.plotWidth;
+                const ph = t.plotHeight;
+                let tMin = Infinity;
+                if (dx > 0)
+                    tMin = Math.min(tMin, (pw - x0) / dx);
+                else if (dx < 0)
+                    tMin = Math.min(tMin, -x0 / dx);
+                if (dy > 0)
+                    tMin = Math.min(tMin, (ph - y0) / dy);
+                else if (dy < 0)
+                    tMin = Math.min(tMin, -y0 / dy);
+                const ex = tMin === Infinity ? x0 : x0 + dx * tMin;
+                const ey = tMin === Infinity ? y0 : y0 + dy * tMin;
+                return this._distPointToSegment(mx, my, x0, y0, ex, ey);
+            }
+            case 'rectangle': {
+                const p0 = drawing.points[0];
+                const p1 = drawing.points[1];
+                if (!p0 || !p1)
+                    return Infinity;
+                const rx = Math.min(t.timeToX(p0.time), t.timeToX(p1.time));
+                const ry = Math.min(t.priceToY(p0.price), t.priceToY(p1.price));
+                const rw = Math.abs(t.timeToX(p1.time) - t.timeToX(p0.time));
+                const rh = Math.abs(t.priceToY(p1.price) - t.priceToY(p0.price));
+                return this._distToRect(mx, my, rx, ry, rw, rh);
+            }
+            case 'text': {
+                const p0 = drawing.points[0];
+                if (!p0)
+                    return Infinity;
+                const px = t.timeToX(p0.time);
+                const py = t.priceToY(p0.price);
+                // Approximate bounding box
+                const fs = drawing.fontSize ?? 13;
+                return this._distToRect(mx, my, px, py - fs - 8, 80, fs + 8);
+            }
+            // ── new line types (two-anchor, infinite or extended) ──────────────
+            case 'infoLine':
+            case 'extendedLine':
+            case 'trendAngle': {
+                const p0 = drawing.points[0];
+                const p1 = drawing.points[1];
+                if (!p0 || !p1)
+                    return Infinity;
+                // Approximate by segment; close enough for hit-testing
+                return this._distPointToSegment(mx, my, t.timeToX(p0.time), t.priceToY(p0.price), t.timeToX(p1.time), t.priceToY(p1.price));
+            }
+            case 'horizontalRay': {
+                const p0 = drawing.points[0];
+                if (!p0)
+                    return Infinity;
+                const x0 = t.timeToX(p0.time);
+                const y = t.priceToY(p0.price);
+                if (mx < x0)
+                    return Infinity;
+                return Math.abs(my - y);
+            }
+            case 'crossLine': {
+                const p0 = drawing.points[0];
+                if (!p0)
+                    return Infinity;
+                const x = t.timeToX(p0.time);
+                const y = t.priceToY(p0.price);
+                return Math.min(Math.abs(my - y), Math.abs(mx - x));
+            }
+            // ── channels ──────────────────────────────────────────────────────
+            case 'parallelChannel':
+            case 'flatTopBottom':
+            case 'regressionTrend':
+            case 'disjointChannel': {
+                const p0 = drawing.points[0];
+                const p1 = drawing.points[1];
+                if (!p0 || !p1)
+                    return Infinity;
+                const d0 = this._distPointToSegment(mx, my, t.timeToX(p0.time), t.priceToY(p0.price), t.timeToX(p1.time), t.priceToY(p1.price));
+                const p2 = drawing.points[2];
+                if (!p2)
+                    return d0;
+                const d1 = this._distPointToSegment(mx, my, t.timeToX(p0.time), t.priceToY(p2.price), t.timeToX(p1.time), t.priceToY(p2.price));
+                return Math.min(d0, d1);
+            }
+            // ── pitchforks ────────────────────────────────────────────────────
+            case 'pitchfork':
+            case 'schiffPitchfork':
+            case 'modifiedSchiffPitchfork':
+            case 'insidePitchfork': {
+                const p0 = drawing.points[0];
+                const p1 = drawing.points[1];
+                const p2 = drawing.points[2];
+                if (!p0 || !p1)
+                    return Infinity;
+                let best = this._distPointToSegment(mx, my, t.timeToX(p0.time), t.priceToY(p0.price), t.timeToX(p1.time), t.priceToY(p1.price));
+                if (p2) {
+                    best = Math.min(best, this._distPointToSegment(mx, my, t.timeToX(p0.time), t.priceToY(p0.price), t.timeToX(p2.time), t.priceToY(p2.price)));
+                }
+                return best;
+            }
+            default:
+                // Fib/Gann and future drawing types are not hit-testable yet.
+                return Infinity;
+        }
+    }
+    /**
+     * Returns the nearest visible bar to x-coordinate `mx`, or `null` if no bar
+     * falls within half a bar-width.
+     */
+    _hitTestBar(mx) {
+        const t = this._transform;
+        const { from, to } = t.timeRange;
+        const visibleSeconds = Math.max(1, to - from);
+        const barHalfPx = (t.plotWidth / visibleSeconds) / 2;
+        let bestIndex = -1;
+        let bestDist = Infinity;
+        for (let i = 0; i < this._bars.length; i++) {
+            const bar = this._bars[i];
+            if (!bar || bar.time < from || bar.time > to)
+                continue;
+            const dist = Math.abs(mx - t.timeToX(bar.time));
+            if (dist < bestDist) {
+                bestDist = dist;
+                bestIndex = i;
+            }
+        }
+        if (bestIndex < 0 || bestDist > barHalfPx)
+            return null;
+        const bar = this._bars[bestIndex];
+        if (!bar)
+            return null;
+        return { index: bestIndex, bar };
+    }
+    // ─── Geometry helpers ────────────────────────────────────────────────────
+    /** Distance from point (px, py) to line segment (x1,y1)→(x2,y2). */
+    _distPointToSegment(px, py, x1, y1, x2, y2) {
+        const dx = x2 - x1;
+        const dy = y2 - y1;
+        const lenSq = dx * dx + dy * dy;
+        if (lenSq === 0)
+            return Math.hypot(px - x1, py - y1);
+        const t = Math.max(0, Math.min(1, ((px - x1) * dx + (py - y1) * dy) / lenSq));
+        return Math.hypot(px - (x1 + t * dx), py - (y1 + t * dy));
+    }
+    /**
+     * Minimum distance from point (px, py) to the perimeter of an
+     * axis-aligned rectangle.  Returns 0 if the point is inside.
+     */
+    _distToRect(px, py, rx, ry, rw, rh) {
+        const inside = px >= rx && px <= rx + rw &&
+            py >= ry && py <= ry + rh;
+        if (inside)
+            return 0;
+        return Math.min(this._distPointToSegment(px, py, rx, ry, rx + rw, ry), this._distPointToSegment(px, py, rx + rw, ry, rx + rw, ry + rh), this._distPointToSegment(px, py, rx + rw, ry + rh, rx, ry + rh), this._distPointToSegment(px, py, rx, ry + rh, rx, ry));
+    }
+}
+//# sourceMappingURL=InteractionManager.js.map