be-components 7.4.7 → 7.5.1

package/src/Charts/adapters/TradeChartAdapter.ts

@@ -0,0 +1,471 @@
+/**
+ * Trade Chart Adapter
+ * Converts BettorEdge TradeProps to chart-ready format
+ * This is the middle layer that transforms your app's trade types to chart data structures
+ */
+
+import type { TimeSeriesData, TimeSeriesPoint } from '../types';
+import type { TradeProps, MarketProps } from '../../types';
+import { getAwayHomeGradients } from '../themes/chartTheme';
+import { formatTime } from '../utils/formatters';
+
+/**
+ * Re-export TradeProps for convenience
+ */
+export type Trade = TradeProps;
+
+/**
+ * Side label mapping
+ */
+export interface SideLabel {
+    side: string;
+    label: string;
+}
+
+/**
+ * Time range filter options
+ */
+export type TimeRangeFilter = 'today' | 'last_24h' | 'last_week' | 'last_month' | 'all_time' | 'custom';
+
+/**
+ * Options for trade chart transformation
+ */
+export interface TradeChartOptions {
+    /** Limit number of data points (for performance) */
+    maxPoints?: number;
+    /** Smooth data by interpolation */
+    smoothing?: boolean;
+    /** Show data point markers */
+    showDataPoints?: boolean;
+    /** Curve lines */
+    curved?: boolean;
+    /** Enable gradient fills */
+    gradient?: boolean;
+    /** Side labels mapping array (e.g., [{side: 'away', label: 'Lakers'}]) */
+    sideLabels?: SideLabel[];
+    /** Time range filter (auto-determines sampling rate) */
+    timeFilter?: TimeRangeFilter;
+    /** Custom time range (used with timeFilter='custom') */
+    customTimeRange?: {
+        start: Date | number;
+        end: Date | number;
+    };
+    /** Enable smart sampling (automatically determines best sample rate based on data span) */
+    smartSampling?: boolean;
+}
+
+/**
+ * TradeChartAdapter
+ * Handles transformation of trade data to chart format
+ */
+export class TradeChartAdapter {
+    /**
+     * Create reversed trades from single-side trade data
+     * Takes trades from one side (e.g., home) and creates the opposite side (e.g., away)
+     * @param trades Array of trades from one side
+     * @param market Market object with trade_side and side_options
+     * @returns Array with both original and reversed trades
+     */
+    static createReversedTrades(trades: Trade[], market: MarketProps): Trade[] {
+        // Get the opposite side from side_options
+        const tradeSide = market.trade_side;
+        const oppositeSideOption = market.side_options.find(opt => opt.side !== tradeSide);
+
+        if (!oppositeSideOption) {
+            // If no opposite side found, return original trades
+            return trades;
+        }
+
+        const oppositeSide = oppositeSideOption.side;
+
+        // Create reversed trades
+        const reversedTrades: Trade[] = trades.map(trade => ({
+            ...trade,
+            side: oppositeSide,
+            side_id: trade.reversed_side_id,
+            reversed_side_id: trade.side_id, // Swap the reversed_side_id
+            probability: 1 - trade.probability, // Invert probability
+            odds: trade.odds * -1, // Reverse odds
+        }));
+
+        // Return both original and reversed trades
+        return [...trades, ...reversedTrades];
+    }
+
+    /**
+     * Convert array of BettorEdge trades to time series chart data
+     * @param trades Array of TradeProps objects
+     * @param options Transformation options
+     * @returns Array of TimeSeriesData (side series based on side_id)
+     */
+    static toTimeSeriesData(
+        trades: Trade[],
+        options: TradeChartOptions = {}
+    ): TimeSeriesData[] {
+        const {
+            maxPoints = 100,
+            smoothing = false,
+            showDataPoints = false,
+            curved = true,
+            gradient = true,
+            sideLabels = [],
+            timeFilter = 'all_time',
+            customTimeRange,
+            smartSampling = true,
+        } = options;
+
+        // Sort trades by create_datetime (timestamp)
+        const sortedTrades = [...trades].sort((a, b) => {
+            const timeA = new Date(a.create_datetime).getTime();
+            const timeB = new Date(b.create_datetime).getTime();
+            return timeA - timeB;
+        });
+
+        // Apply time range filter
+        const filteredTrades = this.applyTimeFilter(sortedTrades, timeFilter, customTimeRange);
+
+        // Group trades by side_id to create separate series for each side
+        const tradesBySide = this.groupBySide(filteredTrades);
+
+        // Get gradient colors
+        const gradients = getAwayHomeGradients();
+
+        // Create a helper to get label for a side
+        const getSideLabel = (side: string, sideId: string): string => {
+            // First try to find label by side property
+            const labelBySide = sideLabels.find(sl => sl.side === side);
+            if (labelBySide) return labelBySide.label;
+
+            // Fallback to side_id
+            return sideId;
+        };
+
+        // Convert each side to a time series
+        const seriesData: TimeSeriesData[] = [];
+        const sides = Object.keys(tradesBySide);
+
+        sides.forEach((sideId, index) => {
+            // Sort this side's trades by create_datetime to ensure correct order
+            const sideTrades = (tradesBySide[sideId] || []).sort((a, b) => {
+                const timeA = new Date(a.create_datetime).getTime();
+                const timeB = new Date(b.create_datetime).getTime();
+                return timeA - timeB;
+            });
+
+            // Get the side property from the first trade in this group
+            const side = sideTrades[0]?.side || '';
+
+            // Get the display label for this side
+            const displayLabel = getSideLabel(side, sideId);
+
+            // Apply smart sampling or simple limiting
+            const limitedTrades = smartSampling
+                ? this.smartSample(sideTrades, filteredTrades, maxPoints)
+                : this.limitDataPoints(sideTrades, maxPoints);
+
+            // Convert to time series points
+            const points = this.tradesToPoints(limitedTrades);
+
+            // Apply smoothing if requested
+            const finalPoints = smoothing ? this.smoothData(points) : points;
+
+            // Use alternating colors (away/home style)
+            const isFirstSide = index === 0;
+            const colorConfig = isFirstSide ? gradients.away : gradients.home;
+
+            seriesData.push({
+                series: displayLabel, // Use display label as series identifier
+                color: colorConfig.color,
+                data: finalPoints,
+                gradient: gradient,
+                gradientColors: gradient ? colorConfig.gradientColors : undefined,
+                showDataPoints,
+                curved,
+                thickness: 2.5,
+            });
+        });
+
+        return seriesData;
+    }
+
+    /**
+     * Append a new trade to existing chart data
+     * Used for live updates
+     */
+    static appendTrade(
+        existingData: TimeSeriesData[],
+        newTrade: Trade,
+        maxPoints: number = 100
+    ): TimeSeriesData[] {
+        return existingData.map(series => {
+            // Only add to matching series (by side_id)
+            if (series.series === newTrade.side_id) {
+                const timestamp = new Date(newTrade.create_datetime).getTime();
+                const newPoint: TimeSeriesPoint = {
+                    timestamp,
+                    value: newTrade.probability,
+                    label: formatTime(timestamp),
+                    metadata: newTrade,
+                };
+
+                // Append and limit
+                const updatedData = [...series.data, newPoint];
+                return {
+                    ...series,
+                    data: updatedData.slice(-maxPoints), // Keep only last N points
+                };
+            }
+            return series;
+        });
+    }
+
+    /**
+     * Group trades by side_id
+     */
+    private static groupBySide(trades: Trade[]): Record<string, Trade[]> {
+        return trades.reduce((acc, trade) => {
+            if (!acc[trade.side_id]) {
+                acc[trade.side_id] = [];
+            }
+            acc[trade.side_id]!.push(trade);
+            return acc;
+        }, {} as Record<string, Trade[]>);
+    }
+
+    /**
+     * Convert trades to TimeSeriesPoints
+     */
+    private static tradesToPoints(trades: Trade[]): TimeSeriesPoint[] {
+        return trades.map(trade => {
+            const timestamp = new Date(trade.create_datetime).getTime();
+            return {
+                timestamp,
+                value: trade.probability,
+                label: formatTime(timestamp),
+                metadata: trade,
+            };
+        });
+    }
+
+    /**
+     * Limit data points by sampling
+     * Keeps first, last, and evenly spaced points in between
+     */
+    private static limitDataPoints(trades: Trade[], maxPoints: number): Trade[] {
+        if (trades.length <= maxPoints) return trades;
+
+        const result: Trade[] = [];
+        const step = Math.floor(trades.length / maxPoints);
+
+        for (let i = 0; i < trades.length; i += step) {
+            const trade = trades[i];
+            if (trade) result.push(trade);
+        }
+
+        // Always include the last trade
+        const lastTrade = trades[trades.length - 1];
+        if (lastTrade && result[result.length - 1] !== lastTrade) {
+            result.push(lastTrade);
+        }
+
+        return result;
+    }
+
+    /**
+     * Simple moving average smoothing
+     * Reduces noise in price data
+     * NOTE: Preserves the last point's actual value (no smoothing on most recent trade)
+     */
+    private static smoothData(points: TimeSeriesPoint[], windowSize: number = 3): TimeSeriesPoint[] {
+        if (points.length < windowSize) return points;
+
+        const smoothed: TimeSeriesPoint[] = [];
+        const halfWindow = Math.floor(windowSize / 2);
+
+        for (let i = 0; i < points.length; i++) {
+            const point = points[i];
+            if (!point) continue;
+
+            // For the last point, preserve the actual value (don't smooth it)
+            if (i === points.length - 1) {
+                smoothed.push(point);
+                continue;
+            }
+
+            const start = Math.max(0, i - halfWindow);
+            const end = Math.min(points.length, i + halfWindow + 1);
+            const window = points.slice(start, end);
+
+            const avgValue = window.reduce((sum, p) => sum + p.value, 0) / window.length;
+
+            smoothed.push({
+                ...point,
+                value: avgValue,
+            });
+        }
+
+        return smoothed;
+    }
+
+    /**
+     * Filter trades by time range
+     */
+    static filterByTimeRange(
+        trades: Trade[],
+        startTime: number,
+        endTime: number
+    ): Trade[] {
+        return trades.filter(trade => {
+            const timestamp = new Date(trade.create_datetime).getTime();
+            return timestamp >= startTime && timestamp <= endTime;
+        });
+    }
+
+    /**
+     * Get price statistics from trades
+     */
+    static getStats(trades: Trade[]): {
+        min: number;
+        max: number;
+        avg: number;
+        latest: number;
+        change: number;
+    } {
+        if (trades.length === 0) {
+            return { min: 0, max: 0, avg: 0, latest: 0, change: 0 };
+        }
+
+        const prices = trades.map(t => t.probability);
+        const min = Math.min(...prices);
+        const max = Math.max(...prices);
+        const avg = prices.reduce((sum, p) => sum + p, 0) / prices.length;
+        const latest = prices[prices.length - 1] ?? 0;
+        const first = prices[0] ?? 0;
+        const change = latest - first;
+
+        return { min, max, avg, latest, change };
+    }
+
+    /**
+     * Apply time range filter to trades
+     */
+    private static applyTimeFilter(
+        trades: Trade[],
+        filter: TimeRangeFilter,
+        customRange?: { start: Date | number; end: Date | number }
+    ): Trade[] {
+        if (trades.length === 0) return trades;
+
+        const now = new Date().getTime();
+        let startTime: number;
+        let endTime: number = now;
+
+        switch (filter) {
+            case 'today':
+                // From start of today
+                const today = new Date();
+                today.setHours(0, 0, 0, 0);
+                startTime = today.getTime();
+                break;
+            case 'last_24h':
+                startTime = now - (24 * 60 * 60 * 1000);
+                break;
+            case 'last_week':
+                startTime = now - (7 * 24 * 60 * 60 * 1000);
+                break;
+            case 'last_month':
+                startTime = now - (30 * 24 * 60 * 60 * 1000);
+                break;
+            case 'custom':
+                if (!customRange) return trades;
+                startTime = typeof customRange.start === 'number'
+                    ? customRange.start
+                    : new Date(customRange.start).getTime();
+                endTime = typeof customRange.end === 'number'
+                    ? customRange.end
+                    : new Date(customRange.end).getTime();
+                break;
+            case 'all_time':
+            default:
+                return trades; // No filtering
+        }
+
+        return this.filterByTimeRange(trades, startTime, endTime);
+    }
+
+    /**
+     * Smart sampling based on data timespan
+     * Automatically determines optimal sample interval
+     */
+    private static smartSample(
+        trades: Trade[],
+        allTrades: Trade[],
+        maxPoints: number
+    ): Trade[] {
+        if (trades.length <= maxPoints) return trades;
+
+        // Calculate timespan of all data
+        const firstTrade = allTrades[0];
+        const lastTrade = allTrades[allTrades.length - 1];
+        if (!firstTrade || !lastTrade) return trades;
+
+        const firstTime = new Date(firstTrade.create_datetime).getTime();
+        const lastTime = new Date(lastTrade.create_datetime).getTime();
+        const totalSpanMs = lastTime - firstTime;
+
+        // Determine sampling interval based on timespan
+        let sampleIntervalMs: number;
+
+        if (totalSpanMs <= 60 * 60 * 1000) {
+            // Less than 1 hour: sample every minute
+            sampleIntervalMs = 60 * 1000;
+        } else if (totalSpanMs <= 24 * 60 * 60 * 1000) {
+            // Less than 1 day: sample every 5 minutes
+            sampleIntervalMs = 5 * 60 * 1000;
+        } else if (totalSpanMs <= 7 * 24 * 60 * 60 * 1000) {
+            // Less than 1 week: sample every 30 minutes
+            sampleIntervalMs = 30 * 60 * 1000;
+        } else if (totalSpanMs <= 30 * 24 * 60 * 60 * 1000) {
+            // Less than 1 month: sample every 3 hours
+            sampleIntervalMs = 3 * 60 * 60 * 1000;
+        } else {
+            // More than 1 month: sample every 12 hours
+            sampleIntervalMs = 12 * 60 * 60 * 1000;
+        }
+
+        // Sample trades at intervals
+        const sampledTrades: Trade[] = [];
+
+        // Always include first trade
+        const firstSampledTrade = trades[0];
+        if (!firstSampledTrade) return trades;
+
+        sampledTrades.push(firstSampledTrade);
+        let lastSampleTime = new Date(firstSampledTrade.create_datetime).getTime();
+
+        for (let i = 1; i < trades.length; i++) {
+            const trade = trades[i];
+            if (!trade) continue;
+
+            const tradeTime = new Date(trade.create_datetime).getTime();
+
+            if (tradeTime - lastSampleTime >= sampleIntervalMs) {
+                sampledTrades.push(trade);
+                lastSampleTime = tradeTime;
+            }
+        }
+
+        // Always include last trade
+        const lastSampledTrade = trades[trades.length - 1];
+        if (lastSampledTrade && sampledTrades[sampledTrades.length - 1] !== lastSampledTrade) {
+            sampledTrades.push(lastSampledTrade);
+        }
+
+        // If still too many points, fallback to simple limiting
+        if (sampledTrades.length > maxPoints) {
+            return this.limitDataPoints(sampledTrades, maxPoints);
+        }
+
+        return sampledTrades;
+    }
+}