overtime-live-trading-utils 2.1.22 → 2.1.24

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "overtime-live-trading-utils",
-    "version": "2.1.22",
+    "version": "2.1.24",
     "description": "",
     "main": "main.js",
     "scripts": {

package/src/tests/unit/resolution.test.ts

@@ -1,8 +1,8 @@
 import {
     detectCompletedPeriods,
-    canResolveMarketForGameIdAndSport,
-    canResolveMarketViaOpticOddsApi,
     canResolveMarketsForEvent,
+    canResolveMultipleTypeIdsForEvent,
+    filterMarketsThatCanBeResolved,
 } from '../../utils/resolution';
 import { SportPeriodType } from '../../types/resolution';
 import {
@@ -570,173 +570,6 @@ describe('Resolution Utils', () => {
         });
     });
 
-    describe('canResolveMarketForGameIdAndSport', () => {
-        it('Should return true when game can be resolved', () => {
-            const event = {
-                sport: {
-                    name: 'Soccer',
-                },
-                fixture: {
-                    id: 'match-123',
-                    status: 'live',
-                    is_live: true,
-                },
-                scores: {
-                    home: {
-                        total: 2.0,
-                        periods: {
-                            period_1: 1.0,
-                        },
-                    },
-                    away: {
-                        total: 1.0,
-                        periods: {
-                            period_1: 1.0,
-                        },
-                    },
-                },
-                in_play: {
-                    period: '2',
-                },
-            };
-
-            const result = canResolveMarketForGameIdAndSport('match-123', event);
-
-            expect(result).toBe(true);
-        });
-
-        it('Should return false when gameId does not match', () => {
-            const event = {
-                sport: {
-                    name: 'Soccer',
-                },
-                fixture: {
-                    id: 'match-456',
-                    status: 'live',
-                    is_live: true,
-                },
-                scores: {
-                    home: {
-                        total: 1.0,
-                        periods: {
-                            period_1: 1.0,
-                        },
-                    },
-                    away: {
-                        total: 0.0,
-                        periods: {
-                            period_1: 0.0,
-                        },
-                    },
-                },
-                in_play: {
-                    period: '2',
-                },
-            };
-
-            const result = canResolveMarketForGameIdAndSport('match-999', event);
-
-            expect(result).toBe(false);
-        });
-
-        it('Should return false when no periods are completed', () => {
-            const event = {
-                sport: {
-                    name: 'Basketball',
-                },
-                fixture: {
-                    id: 'match-789',
-                    status: 'live',
-                    is_live: true,
-                },
-                scores: {
-                    home: {
-                        total: 15.0,
-                        periods: {},
-                    },
-                    away: {
-                        total: 12.0,
-                        periods: {},
-                    },
-                },
-                in_play: {
-                    period: '1',
-                },
-            };
-
-            const result = canResolveMarketForGameIdAndSport('match-789', event);
-
-            expect(result).toBe(false);
-        });
-    });
-
-    describe('canResolveMarketViaOpticOddsApi', () => {
-        it('Should return period resolution data when available', () => {
-            const event = {
-                sport: {
-                    name: 'Tennis',
-                },
-                fixture: {
-                    id: 'api-test-1',
-                    status: 'live',
-                    is_live: true,
-                },
-                scores: {
-                    home: {
-                        total: 1.0,
-                        periods: {
-                            period_1: 7.0,
-                        },
-                    },
-                    away: {
-                        total: 0.0,
-                        periods: {
-                            period_1: 5.0,
-                        },
-                    },
-                },
-                in_play: {
-                    period: '2',
-                },
-            };
-
-            const result = canResolveMarketViaOpticOddsApi(event);
-
-            expect(result).not.toBeNull();
-            expect(result?.completedPeriods).toEqual([1]);
-            expect(result?.readyForResolution).toBe(true);
-        });
-
-        it('Should return null when no periods completed', () => {
-            const event = {
-                sport: {
-                    name: 'Soccer',
-                },
-                fixture: {
-                    id: 'api-test-2',
-                    status: 'live',
-                    is_live: true,
-                },
-                scores: {
-                    home: {
-                        total: 0.0,
-                        periods: {},
-                    },
-                    away: {
-                        total: 0.0,
-                        periods: {},
-                    },
-                },
-                in_play: {
-                    period: '1',
-                },
-            };
-
-            const result = canResolveMarketViaOpticOddsApi(event);
-
-            expect(result).toBeNull();
-        });
-    });
 
     describe('canResolveMarketsForEvent', () => {
         describe('Single typeId checks', () => {
@@ -796,35 +629,35 @@ describe('Resolution Utils', () => {
         describe('Batch typeIds checks', () => {
             it('Should return only resolvable typeIds for live soccer in 2nd half', () => {
                 const typeIds = [10021, 10022, 10031, 10001];
-                const result = canResolveMarketsForEvent(MockSoccerLiveSecondHalf, typeIds, SportPeriodType.HALVES_BASED);
+                const result = filterMarketsThatCanBeResolved(MockSoccerLiveSecondHalf, typeIds, SportPeriodType.HALVES_BASED);
 
                 expect(result).toEqual([10021, 10031]); // Only period 1 typeIds
             });
 
             it('Should exclude full game typeIds during live game', () => {
                 const typeIds = [10021, 10001, 10002, 10003];
-                const result = canResolveMarketsForEvent(MockNFLLiveThirdQuarter, typeIds, SportPeriodType.QUARTERS_BASED);
+                const result = filterMarketsThatCanBeResolved(MockNFLLiveThirdQuarter, typeIds, SportPeriodType.QUARTERS_BASED);
 
                 expect(result).toEqual([10021]); // Full game typeIds excluded
             });
 
             it('Should include full game typeIds when game is completed', () => {
                 const typeIds = [10021, 10022, 10001, 10002];
-                const result = canResolveMarketsForEvent(MockSoccerCompletedEvent, typeIds, SportPeriodType.HALVES_BASED);
+                const result = filterMarketsThatCanBeResolved(MockSoccerCompletedEvent, typeIds, SportPeriodType.HALVES_BASED);
 
                 expect(result).toEqual([10021, 10022, 10001, 10002]);
             });
 
             it('Should return empty array when no typeIds are resolvable', () => {
                 const typeIds = [10022, 10023, 10024];
-                const result = canResolveMarketsForEvent(MockSoccerLiveSecondHalf, typeIds, SportPeriodType.HALVES_BASED);
+                const result = filterMarketsThatCanBeResolved(MockSoccerLiveSecondHalf, typeIds, SportPeriodType.HALVES_BASED);
 
                 expect(result).toEqual([]);
             });
 
             it('Should return multiple period typeIds for NFL game in 3rd quarter', () => {
                 const typeIds = [10021, 10022, 10023, 10024, 10031, 10032, 10051];
-                const result = canResolveMarketsForEvent(MockNFLLiveThirdQuarter, typeIds, SportPeriodType.QUARTERS_BASED);
+                const result = filterMarketsThatCanBeResolved(MockNFLLiveThirdQuarter, typeIds, SportPeriodType.QUARTERS_BASED);
 
                 // Periods 1 and 2 are complete (period 2 also completes 1st half = 10051)
                 expect(result).toEqual([10021, 10022, 10031, 10032, 10051]);
@@ -832,19 +665,78 @@ describe('Resolution Utils', () => {
 
             it('Should handle all 9 periods for completed MLB game', () => {
                 const typeIds = [10021, 10022, 10023, 10024, 10025, 10026, 10027, 10028, 10029];
-                const result = canResolveMarketsForEvent(MockMLBCompletedEvent, typeIds, SportPeriodType.INNINGS_BASED);
+                const result = filterMarketsThatCanBeResolved(MockMLBCompletedEvent, typeIds, SportPeriodType.INNINGS_BASED);
 
                 expect(result).toEqual(typeIds); // All 9 innings complete
             });
 
             it('Should return empty array when no periods complete', () => {
                 const typeIds = [10021, 10022, 10031];
-                const result = canResolveMarketsForEvent(MockSoccerLiveFirstHalf, typeIds, SportPeriodType.HALVES_BASED);
+                const result = filterMarketsThatCanBeResolved(MockSoccerLiveFirstHalf, typeIds, SportPeriodType.HALVES_BASED);
 
                 expect(result).toEqual([]);
             });
         });
 
+        describe('Multiple typeIds boolean array checks', () => {
+            it('Should return boolean array for live soccer in 2nd half', () => {
+                const typeIds = [10021, 10022, 10031, 10001];
+                const result = canResolveMultipleTypeIdsForEvent(MockSoccerLiveSecondHalf, typeIds, SportPeriodType.HALVES_BASED);
+
+                expect(result).toEqual([true, false, true, false]); // Period 1 typeIds are true, period 2 and full game are false
+            });
+
+            it('Should return false for full game typeIds during live game', () => {
+                const typeIds = [10021, 10001, 10002, 10003];
+                const result = canResolveMultipleTypeIdsForEvent(MockNFLLiveThirdQuarter, typeIds, SportPeriodType.QUARTERS_BASED);
+
+                expect(result).toEqual([true, false, false, false]); // Only period 1 is true
+            });
+
+            it('Should return all true for completed game', () => {
+                const typeIds = [10021, 10022, 10001, 10002];
+                const result = canResolveMultipleTypeIdsForEvent(MockSoccerCompletedEvent, typeIds, SportPeriodType.HALVES_BASED);
+
+                expect(result).toEqual([true, true, true, true]); // All complete
+            });
+
+            it('Should return all false when no typeIds are resolvable', () => {
+                const typeIds = [10022, 10023, 10024];
+                const result = canResolveMultipleTypeIdsForEvent(MockSoccerLiveSecondHalf, typeIds, SportPeriodType.HALVES_BASED);
+
+                expect(result).toEqual([false, false, false]);
+            });
+
+            it('Should return mixed booleans for NFL game in 3rd quarter', () => {
+                const typeIds = [10021, 10022, 10023, 10024, 10031, 10032, 10051];
+                const result = canResolveMultipleTypeIdsForEvent(MockNFLLiveThirdQuarter, typeIds, SportPeriodType.QUARTERS_BASED);
+
+                // Periods 1 and 2 are complete (period 2 also completes 1st half = 10051)
+                expect(result).toEqual([true, true, false, false, true, true, true]);
+            });
+
+            it('Should handle all 9 periods for completed MLB game', () => {
+                const typeIds = [10021, 10022, 10023, 10024, 10025, 10026, 10027, 10028, 10029];
+                const result = canResolveMultipleTypeIdsForEvent(MockMLBCompletedEvent, typeIds, SportPeriodType.INNINGS_BASED);
+
+                expect(result).toEqual([true, true, true, true, true, true, true, true, true]); // All 9 innings complete
+            });
+
+            it('Should return all false when no periods complete', () => {
+                const typeIds = [10021, 10022, 10031];
+                const result = canResolveMultipleTypeIdsForEvent(MockSoccerLiveFirstHalf, typeIds, SportPeriodType.HALVES_BASED);
+
+                expect(result).toEqual([false, false, false]);
+            });
+
+            it('Should work with numeric sport type parameter', () => {
+                const typeIds = [10021, 10022];
+                const result = canResolveMultipleTypeIdsForEvent(MockSoccerLiveSecondHalf, typeIds, 0); // 0 = HALVES_BASED
+
+                expect(result).toEqual([true, false]);
+            });
+        });
+
         describe('Edge cases', () => {
             it('Should handle event with no completed periods', () => {
                 const result = canResolveMarketsForEvent(MockSoccerLiveFirstHalfInProgress, 10021, SportPeriodType.HALVES_BASED);
@@ -867,7 +759,7 @@ describe('Resolution Utils', () => {
             });
 
             it('Should work with sport type parameter for batch typeIds', () => {
-                const result = canResolveMarketsForEvent(MockSoccerLiveSecondHalf, [10021, 10022], SportPeriodType.HALVES_BASED);
+                const result = filterMarketsThatCanBeResolved(MockSoccerLiveSecondHalf, [10021, 10022], SportPeriodType.HALVES_BASED);
                 expect(result).toEqual([10021]);
             });
         });
@@ -901,7 +793,7 @@ describe('Resolution Utils', () => {
 
             it('Should return all resolvable typeIds including overtime in batch check', () => {
                 const typeIds = [10021, 10022, 10023, 10024, 10025, 10001];
-                const result = canResolveMarketsForEvent(MockNFLCompletedWithOvertime, typeIds, SportPeriodType.QUARTERS_BASED);
+                const result = filterMarketsThatCanBeResolved(MockNFLCompletedWithOvertime, typeIds, SportPeriodType.QUARTERS_BASED);
 
                 expect(result).toEqual(typeIds); // All should be resolvable (game completed with overtime)
             });
@@ -918,7 +810,7 @@ describe('Resolution Utils', () => {
 
             it('Should not include non-existent periods in batch check', () => {
                 const typeIds = [10021, 10022, 10025, 10028, 10029];
-                const result = canResolveMarketsForEvent(MockNFLCompletedWithOvertime, typeIds, SportPeriodType.QUARTERS_BASED);
+                const result = filterMarketsThatCanBeResolved(MockNFLCompletedWithOvertime, typeIds, SportPeriodType.QUARTERS_BASED);
 
                 // Only periods 1, 2, and 5 occurred, so only their typeIds should be returned
                 expect(result).toEqual([10021, 10022, 10025]);

package/src/utils/resolution.ts

@@ -92,37 +92,6 @@ export const detectCompletedPeriods = (
           }
         : null;
 };
-
-/**
- * Checks if a market can be resolved based on game and sport
- * @param gameId - The game/fixture ID
- * @param event - Event object from OpticOdds API
- * @returns boolean indicating if market can be resolved
- */
-export const canResolveMarketForGameIdAndSport = (
-    gameId: string,
-    event: OpticOddsEvent
-): boolean => {
-    const eventId = event.fixture?.id || event.id || '';
-    if (eventId !== gameId) {
-        return false;
-    }
-
-    const periodData = detectCompletedPeriods(event);
-    return periodData !== null && periodData.readyForResolution;
-};
-
-/**
- * Convenience function to check resolution status via OpticOdds API event
- * @param event - Event object from OpticOdds API
- * @returns PeriodResolutionData if periods are complete, null otherwise
- */
-export const canResolveMarketViaOpticOddsApi = (
-    event: OpticOddsEvent
-): PeriodResolutionData | null => {
-    return detectCompletedPeriods(event);
-};
-
 /**
  * Maps a numeric value to a SportPeriodType enum
  * @param sportTypeNum - Numeric representation of sport type (0 = halves, 1 = quarters, 2 = innings, 3 = period)
@@ -163,32 +132,87 @@ function selectMappingForSportType(sportType: SportPeriodType): { [period: numbe
 }
 
 /**
- * Implementation - checks if specific market type(s) can be resolved based on completed periods
+ * Checks if a specific market type can be resolved based on completed periods (Enum version)
  *
  * @example
  * // Check single typeId for NFL (quarters-based)
  * const canResolve = canResolveMarketsForEvent(event, 10021, SportPeriodType.QUARTERS_BASED);
- * // Or using number
- * const canResolve = canResolveMarketsForEvent(event, 10021, 1);
- *
- * // Check batch of typeIds for MLB (innings-based)
- * const resolvable = canResolveMarketsForEvent(event, [10021, 10051], SportPeriodType.INNINGS_BASED);
- * // Returns: [10021] if only period 1-4 complete, [10021, 10051] if period 5 complete
  *
  * // Check with period-based (no halves/secondary moneyline)
  * const canResolve = canResolveMarketsForEvent(event, 10021, SportPeriodType.PERIOD_BASED);
- * // Or using number
- * const canResolve = canResolveMarketsForEvent(event, 10021, 3);
+ *
+ * @param event - OpticOdds event object containing fixture data
+ * @param typeId - The market type identifier
+ * @param sportType - The sport period type enum
+ * @returns true if the market can be resolved based on completed periods
  */
 export function canResolveMarketsForEvent(
     event: OpticOddsEvent,
-    typeIdOrTypeIds: number | number[],
+    typeId: number,
+    sportType: SportPeriodType
+): boolean {
+    const periodData = detectCompletedPeriods(event);
+    if (!periodData) return false;
+
+    const status = (event.fixture?.status || event.status || '').toLowerCase();
+    const isCompleted = status === 'completed' || status === 'complete' || status === 'finished';
+
+    // Full game typeIds can only be resolved when game is completed
+    if (FULL_GAME_TYPE_IDS.includes(typeId)) {
+        return isCompleted;
+    }
+
+    // Select appropriate mapping based on sport type
+    const mapping = selectMappingForSportType(sportType);
+
+    const resolvableTypeIds = new Set<number>();
+    for (const period of periodData.completedPeriods) {
+        const typeIdsForPeriod = mapping[period] || [];
+        typeIdsForPeriod.forEach((id) => resolvableTypeIds.add(id));
+    }
+
+    return resolvableTypeIds.has(typeId);
+}
+
+/**
+ * Checks if a specific market type can be resolved based on completed periods (Number version)
+ *
+ * @example
+ * // Check single typeId for NFL (quarters-based)
+ * const canResolve = canResolveMarketsForEventNumber(event, 10021, 1);
+ *
+ * @param event - OpticOdds event object containing fixture data
+ * @param typeId - The market type identifier
+ * @param sportTypeNumber - Numeric value representing the sport period type
+ * @returns true if the market can be resolved based on completed periods
+ */
+export function canResolveMarketsForEventNumber(
+    event: OpticOddsEvent,
+    typeId: number,
+    sportTypeNumber: number
+): boolean {
+    const sportTypeEnum = mapNumberToSportPeriodType(sportTypeNumber);
+    return canResolveMarketsForEvent(event, typeId, sportTypeEnum);
+}
+
+
+/**
+ * Checks if multiple market types can be resolved, returning a boolean for each
+ *
+ * @example
+ * // Check multiple typeIds for MLB (innings-based)
+ * const canResolve = canResolveMultipleTypeIdsForEvent(event, [10021, 10051], SportPeriodType.INNINGS_BASED);
+ * // Returns: [true, false] if only 10021 can be resolved
+ */
+export function canResolveMultipleTypeIdsForEvent(
+    event: OpticOddsEvent,
+    typeIds: number[],
     sportType: SportPeriodType | number
-): boolean | number[] {
+): boolean[] {
     // Get completed periods
     const periodData = detectCompletedPeriods(event);
     if (!periodData) {
-        return Array.isArray(typeIdOrTypeIds) ? [] : false;
+        return typeIds.map(() => false);
     }
 
     // Check if game is fully completed
@@ -209,21 +233,59 @@ export function canResolveMarketsForEvent(
         typeIdsForPeriod.forEach((id) => resolvableTypeIds.add(id));
     }
 
-    // Single typeId check
-    if (typeof typeIdOrTypeIds === 'number') {
+    // Map each typeId to a boolean
+    return typeIds.map((id) => {
         // Full game typeIds can only be resolved when game is completed
-        if (FULL_GAME_TYPE_IDS.includes(typeIdOrTypeIds)) {
+        if (FULL_GAME_TYPE_IDS.includes(id)) {
             return isCompleted;
         }
-        return resolvableTypeIds.has(typeIdOrTypeIds);
+        return resolvableTypeIds.has(id);
+    });
+}
+
+/**
+ * Filters a list of market types to only those that can be resolved
+ *
+ * @example
+ * // Filter typeIds for MLB (innings-based)
+ * const resolvable = filterMarketsThatCanBeResolved(event, [10021, 10051, 10061], SportPeriodType.INNINGS_BASED);
+ * // Returns: [10021] if only period 1-4 complete, [10021, 10051] if period 5 complete
+ */
+export function filterMarketsThatCanBeResolved(
+    event: OpticOddsEvent,
+    typeIds: number[],
+    sportType: SportPeriodType | number
+): number[] {
+    // Get completed periods
+    const periodData = detectCompletedPeriods(event);
+    if (!periodData) {
+        return [];
     }
 
-    // Batch typeIds check
-    return typeIdOrTypeIds.filter((id) => {
+    // Check if game is fully completed
+    const status = (event.fixture?.status || event.status || '').toLowerCase();
+    const isCompleted = status === 'completed' || status === 'complete' || status === 'finished';
+
+    // Convert number to SportPeriodType if needed
+    const sportTypeEnum = typeof sportType === 'number' ? mapNumberToSportPeriodType(sportType) : sportType;
+
+    // Select appropriate mapping based on sport type
+    const mapping = selectMappingForSportType(sportTypeEnum);
+
+    // Collect all resolvable typeIds based on completed periods
+    const resolvableTypeIds = new Set<number>();
+
+    for (const period of periodData.completedPeriods) {
+        const typeIdsForPeriod = mapping[period] || [];
+        typeIdsForPeriod.forEach((id) => resolvableTypeIds.add(id));
+    }
+
+    // Filter typeIds to only those that can be resolved
+    return typeIds.filter((id) => {
         // Full game typeIds can only be resolved when game is completed
         if (FULL_GAME_TYPE_IDS.includes(id)) {
             return isCompleted;
         }
         return resolvableTypeIds.has(id);
     });
-};
+}