@gotza02/sequential-thinking 10000.1.0 → 10000.1.2

package/dist/tools/sports/core/realtime-manager.js

@@ -1,132 +1,77 @@
 /**
  * REALTIME DATA MANAGER
- * WebSocket/SSE based real-time data streaming with fallback polling
+ * Polling-based real-time data streaming
  */
 import { EventEmitter } from 'events';
 import { CacheService } from './cache.js';
-import { logger } from '../../../utils.js';
 import { REALTIME_CONFIG, CACHE_CONFIG } from './constants.js';
+// Simple logger fallback
+const logger = {
+    info: (...args) => console.error('[INFO]', ...args),
+    warn: (...args) => console.warn('[WARN]', ...args),
+    error: (...args) => console.error('[ERROR]', ...args),
+    debug: (...args) => { }
+};
 export class RealtimeDataManager extends EventEmitter {
     cache;
-    wsConnections = new Map();
     pollingIntervals = new Map();
-    reconnectAttempts = new Map();
     isRunning = false;
     constructor() {
         super();
         this.cache = new CacheService();
         this.setMaxListeners(100);
     }
-    /**
-     * Start the realtime manager
-     */
     async start() {
         if (this.isRunning)
             return;
         this.isRunning = true;
         logger.info('[RealtimeManager] Started');
-        // Start polling for live data
         this.startLiveScoresPolling();
         this.startOddsPolling();
     }
-    /**
-     * Stop the realtime manager
-     */
     stop() {
         this.isRunning = false;
-        // Close all WebSocket connections
-        for (const [matchId, ws] of this.wsConnections.entries()) {
-            ws.close();
-        }
-        this.wsConnections.clear();
-        // Clear all polling intervals
         for (const [key, interval] of this.pollingIntervals.entries()) {
             clearInterval(interval);
         }
         this.pollingIntervals.clear();
         logger.info('[RealtimeManager] Stopped');
     }
-    /**
-     * Subscribe to a specific match's events
-     */
     subscribeToMatch(matchId, callback) {
         const eventName = `match:${matchId}`;
         this.on(eventName, callback);
-        // Try to establish WebSocket connection if available
-        this.connectToMatchStream(matchId);
-        // Return unsubscribe function
+        this.startMatchEventsPolling(matchId);
         return () => {
             this.off(eventName, callback);
             this.unsubscribeFromMatch(matchId);
         };
     }
-    /**
-     * Subscribe to odds changes for a match
-     */
     subscribeToOdds(matchId, callback) {
         const eventName = `odds:${matchId}`;
         this.on(eventName, callback);
-        return () => {
-            this.off(eventName, callback);
-        };
+        return () => this.off(eventName, callback);
     }
-    /**
-     * Subscribe to all live events
-     */
     subscribeToAllEvents(callback) {
         this.on('event', callback);
         return () => this.off('event', callback);
     }
-    /**
-     * Process and broadcast an event
-     */
     processEvent(event) {
-        // Update cache
         this.updateCache(event);
-        // Emit to specific match listeners
         this.emit(`match:${event.matchId}`, event);
-        // Emit to odds listeners if it's an odds change
         if (event.type === 'odds_change') {
             this.emit(`odds:${event.matchId}`, event);
         }
-        // Emit to global listeners
         this.emit('event', event);
-        // Log event
-        logger.debug(`[Realtime] Event: ${event.type} | Match: ${event.matchId} | Min: ${event.minute}`);
     }
-    /**
-     * Get current live matches
-     */
     getLiveMatches() {
         const cached = this.cache.get('live:all');
         return cached || [];
     }
-    /**
-     * Get match events history
-     */
     getMatchEvents(matchId) {
         const cached = this.cache.get(`events:${matchId}`);
         return cached || [];
     }
-    /**
-     * Connect to match stream (WebSocket or polling)
-     */
-    async connectToMatchStream(matchId) {
-        // For now, use polling fallback
-        // In production, this would try WebSocket first
-        this.startMatchEventsPolling(matchId);
-    }
-    /**
-     * Unsubscribe from a match
-     */
     unsubscribeFromMatch(matchId) {
-        // Close WebSocket if exists
-        const ws = this.wsConnections.get(matchId);
-        if (ws) {
-            ws.close();
-            this.wsConnections.delete(matchId);
-        }
-        // Clear polling if no more listeners
         const listenerCount = this.listenerCount(`match:${matchId}`);
         if (listenerCount === 0) {
             const interval = this.pollingIntervals.get(`events:${matchId}`);
@@ -136,22 +81,14 @@ export class RealtimeDataManager extends EventEmitter {
             }
         }
     }
-    /**
-     * Start polling for live scores
-     */
     startLiveScoresPolling() {
         const interval = setInterval(async () => {
             if (!this.isRunning)
                 return;
             try {
-                // Fetch live scores from API
-                // This would call your API provider
                 const liveScores = await this.fetchLiveScores();
-                // Update cache
                 this.cache.set('live:all', liveScores, CACHE_CONFIG.TTL.LIVE_SCORES);
-                // Emit update
                 this.emit('live_scores', liveScores);
-                // Check for score changes and emit events
                 this.detectScoreChanges(liveScores);
             }
             catch (error) {
@@ -160,9 +97,6 @@ export class RealtimeDataManager extends EventEmitter {
         }, REALTIME_CONFIG.POLLING_INTERVALS.LIVE_SCORES);
         this.pollingIntervals.set('live_scores', interval);
     }
-    /**
-     * Start polling for odds
-     */
     startOddsPolling() {
         const interval = setInterval(async () => {
             if (!this.isRunning)
@@ -174,7 +108,6 @@ export class RealtimeDataManager extends EventEmitter {
                     if (odds) {
                         const cachedOdds = this.cache.get(`odds:${match.id}`);
                         if (cachedOdds) {
-                            // Detect changes
                             this.detectOddsChanges(match.id, cachedOdds, odds);
                         }
                         this.cache.set(`odds:${match.id}`, odds, CACHE_CONFIG.TTL.ODDS);
@@ -187,9 +120,6 @@ export class RealtimeDataManager extends EventEmitter {
         }, REALTIME_CONFIG.POLLING_INTERVALS.ODDS);
         this.pollingIntervals.set('odds', interval);
     }
-    /**
-     * Start polling for specific match events
-     */
     startMatchEventsPolling(matchId) {
         if (this.pollingIntervals.has(`events:${matchId}`))
             return;
@@ -199,7 +129,6 @@ export class RealtimeDataManager extends EventEmitter {
             try {
                 const events = await this.fetchMatchEvents(matchId);
                 const cachedEvents = this.getMatchEvents(matchId);
-                // Find new events
                 const newEvents = events.filter(e => !cachedEvents.some(ce => ce.timestamp === e.timestamp && ce.type === e.type));
                 for (const event of newEvents) {
                     this.processEvent(event);
@@ -211,49 +140,32 @@ export class RealtimeDataManager extends EventEmitter {
         }, REALTIME_CONFIG.POLLING_INTERVALS.MATCH_EVENTS);
         this.pollingIntervals.set(`events:${matchId}`, interval);
     }
-    /**
-     * Detect score changes and emit goal events
-     */
     detectScoreChanges(matches) {
         for (const match of matches) {
             const cachedMatch = this.cache.get(`match:${match.id}`);
             if (cachedMatch && cachedMatch.score && match.score) {
-                // Check for home team goal
                 if (match.score.home > cachedMatch.score.home) {
                     this.processEvent({
                         type: 'goal',
                         matchId: match.id,
                         timestamp: Date.now(),
                         minute: match.minute,
-                        data: {
-                            team: 'home',
-                            score: match.score,
-                            previousScore: cachedMatch.score,
-                        },
+                        data: { team: 'home', score: match.score, previousScore: cachedMatch.score },
                     });
                 }
-                // Check for away team goal
                 if (match.score.away > cachedMatch.score.away) {
                     this.processEvent({
                         type: 'goal',
                         matchId: match.id,
                         timestamp: Date.now(),
                         minute: match.minute,
-                        data: {
-                            team: 'away',
-                            score: match.score,
-                            previousScore: cachedMatch.score,
-                        },
+                        data: { team: 'away', score: match.score, previousScore: cachedMatch.score },
                     });
                 }
             }
-            // Update match cache
             this.cache.set(`match:${match.id}`, match, CACHE_CONFIG.TTL.MATCH_DETAILS);
         }
     }
-    /**
-     * Detect odds changes and emit events
-     */
     detectOddsChanges(matchId, oldOdds, newOdds) {
         const markets = [
             { key: 'homeWin', name: 'Home Win' },
@@ -265,7 +177,6 @@ export class RealtimeDataManager extends EventEmitter {
             const newValue = newOdds[market.key];
             if (oldValue && newValue && oldValue !== newValue) {
                 const change = ((newValue - oldValue) / oldValue) * 100;
-                // Only emit if change is significant (>5%)
                 if (Math.abs(change) > 5) {
                     this.processEvent({
                         type: 'odds_change',
@@ -285,47 +196,27 @@ export class RealtimeDataManager extends EventEmitter {
             }
         }
     }
-    /**
-     * Update cache with event
-     */
     updateCache(event) {
-        // Invalidate related cache entries
         this.cache.invalidatePattern(`match:${event.matchId}*`);
-        // Store event in history
         const eventsKey = `events:${event.matchId}`;
         const existingEvents = this.cache.get(eventsKey) || [];
         existingEvents.push(event);
-        // Keep only last 100 events
-        if (existingEvents.length > 100) {
+        if (existingEvents.length > 100)
             existingEvents.shift();
-        }
         this.cache.set(eventsKey, existingEvents, CACHE_CONFIG.TTL.LIVE_EVENTS);
     }
-    // Placeholder methods - implement with actual API calls
-    async fetchLiveScores() {
-        // Implement with your API provider
-        return [];
-    }
-    async fetchOdds(matchId) {
-        // Implement with your API provider
-        return null;
-    }
-    async fetchMatchEvents(matchId) {
-        // Implement with your API provider
-        return [];
-    }
+    async fetchLiveScores() { return []; }
+    async fetchOdds(matchId) { return null; }
+    async fetchMatchEvents(matchId) { return []; }
 }
-// Singleton instance
 let globalRealtimeManager = null;
 export function getRealtimeManager() {
-    if (!globalRealtimeManager) {
+    if (!globalRealtimeManager)
         globalRealtimeManager = new RealtimeDataManager();
-    }
     return globalRealtimeManager;
 }
 export function resetRealtimeManager() {
-    if (globalRealtimeManager) {
+    if (globalRealtimeManager)
         globalRealtimeManager.stop();
-    }
     globalRealtimeManager = null;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gotza02/sequential-thinking",
-  "version": "10000.1.0",
+  "version": "10000.1.2",
   "publishConfig": {
     "access": "public"
   },