overtime-live-trading-utils 2.1.36 → 2.1.37-rc.0

package/src/utils/sportPeriodMapping.ts

@@ -1,36 +1,36 @@
-import { OpticOddsEvent, SportPeriodType } from '../types/resolution';
-
-/**
- * Determines the period structure type for a sport based on OpticOdds event data
- * @param event - OpticOdds event object containing sport information
- * @returns SportPeriodType enum value indicating the period structure
- */
-export function getSportPeriodTypeFromEvent(event: OpticOddsEvent): SportPeriodType {
-    const sportId = event.sport?.id?.toLowerCase();
-
-    if (!sportId) {
-        // Default to PERIOD_BASED (no halftime processing) for unknown sports
-        return SportPeriodType.PERIOD_BASED;
-    }
-
-    // Map OpticOdds sport string ID to SportPeriodType
-    switch (sportId) {
-        case 'soccer':
-            return SportPeriodType.HALVES_BASED;
-
-        case 'football':
-        case 'basketball':
-            return SportPeriodType.QUARTERS_BASED;
-
-        case 'baseball':
-            return SportPeriodType.INNINGS_BASED;
-
-        case 'hockey':
-        case 'ice_hockey':
-            return SportPeriodType.PERIOD_BASED;
-
-        default:
-            // Default to PERIOD_BASED (no halftime processing) for unknown sports
-            return SportPeriodType.PERIOD_BASED;
-    }
-}
+import { OpticOddsEvent, SportPeriodType } from '../types/resolution';
+
+/**
+ * Determines the period structure type for a sport based on OpticOdds event data
+ * @param event - OpticOdds event object containing sport information
+ * @returns SportPeriodType enum value indicating the period structure
+ */
+export function getSportPeriodTypeFromEvent(event: OpticOddsEvent): SportPeriodType {
+    const sportId = event.sport?.id?.toLowerCase();
+
+    if (!sportId) {
+        // Default to PERIOD_BASED (no halftime processing) for unknown sports
+        return SportPeriodType.PERIOD_BASED;
+    }
+
+    // Map OpticOdds sport string ID to SportPeriodType
+    switch (sportId) {
+        case 'soccer':
+            return SportPeriodType.HALVES_BASED;
+
+        case 'football':
+        case 'basketball':
+            return SportPeriodType.QUARTERS_BASED;
+
+        case 'baseball':
+            return SportPeriodType.INNINGS_BASED;
+
+        case 'hockey':
+        case 'ice_hockey':
+            return SportPeriodType.PERIOD_BASED;
+
+        default:
+            // Default to PERIOD_BASED (no halftime processing) for unknown sports
+            return SportPeriodType.PERIOD_BASED;
+    }
+}

package/src/utils/sports.ts

@@ -1,51 +1,51 @@
-import { League } from 'overtime-utils';
-import { LeagueConfigInfo } from '../types/sports';
-
-// Methods are using data from live-markets-map.csv
-export const getLiveSupportedLeagues = (leagueInfoArray: LeagueConfigInfo[]) => {
-    const uniqueId = new Set();
-    leagueInfoArray
-        .filter((leagueInfo) => leagueInfo.enabled === 'true')
-        .map((league) => uniqueId.add(Number(league.sportId)));
-    return Array.from(uniqueId);
-};
-
-export const getBetTypesForLeague = (league: League, leagueInfoArray: LeagueConfigInfo[]) => {
-    const uniqueMarketNames = new Set();
-    leagueInfoArray
-        .filter((leagueInfo) => Number(leagueInfo.sportId) === Number(league) && leagueInfo.enabled === 'true')
-        .map((leagueInfo) => uniqueMarketNames.add(leagueInfo.marketName));
-
-    return Array.from(uniqueMarketNames) as string[];
-};
-
-export const getLeagueInfo = (league: League, leagueInfoArray: LeagueConfigInfo[]) => {
-    const leagueInfos = leagueInfoArray.filter((leagueInfo) => Number(leagueInfo.sportId) === league);
-    return leagueInfos;
-};
-
-export const getLeagueSpreadTypes = (league: League, leagueInfoArray: LeagueConfigInfo[]) => {
-    const betTypes = leagueInfoArray
-        .filter(
-            (leagueInfo) =>
-                Number(leagueInfo.sportId) === Number(league) &&
-                leagueInfo.type === 'Spread' &&
-                leagueInfo.enabled === 'true'
-        )
-        .map((leagueInfo) => leagueInfo.marketName.toLowerCase());
-
-    return betTypes;
-};
-
-export const getLeagueTotalTypes = (league: League, leagueInfoArray: LeagueConfigInfo[]) => {
-    const betTypes = leagueInfoArray
-        .filter(
-            (leagueInfo) =>
-                Number(leagueInfo.sportId) === Number(league) &&
-                leagueInfo.type === 'Total' &&
-                leagueInfo.enabled === 'true'
-        )
-        .map((leagueInfo) => leagueInfo.marketName.toLowerCase());
-
-    return betTypes;
-};
+import { League } from 'overtime-utils';
+import { LeagueConfigInfo } from '../types/sports';
+
+// Methods are using data from live-markets-map.csv
+export const getLiveSupportedLeagues = (leagueInfoArray: LeagueConfigInfo[]) => {
+    const uniqueId = new Set();
+    leagueInfoArray
+        .filter((leagueInfo) => leagueInfo.enabled === 'true')
+        .map((league) => uniqueId.add(Number(league.sportId)));
+    return Array.from(uniqueId);
+};
+
+export const getBetTypesForLeague = (league: League, leagueInfoArray: LeagueConfigInfo[]) => {
+    const uniqueMarketNames = new Set();
+    leagueInfoArray
+        .filter((leagueInfo) => Number(leagueInfo.sportId) === Number(league) && leagueInfo.enabled === 'true')
+        .map((leagueInfo) => uniqueMarketNames.add(leagueInfo.marketName));
+
+    return Array.from(uniqueMarketNames) as string[];
+};
+
+export const getLeagueInfo = (league: League, leagueInfoArray: LeagueConfigInfo[]) => {
+    const leagueInfos = leagueInfoArray.filter((leagueInfo) => Number(leagueInfo.sportId) === league);
+    return leagueInfos;
+};
+
+export const getLeagueSpreadTypes = (league: League, leagueInfoArray: LeagueConfigInfo[]) => {
+    const betTypes = leagueInfoArray
+        .filter(
+            (leagueInfo) =>
+                Number(leagueInfo.sportId) === Number(league) &&
+                leagueInfo.type === 'Spread' &&
+                leagueInfo.enabled === 'true'
+        )
+        .map((leagueInfo) => leagueInfo.marketName.toLowerCase());
+
+    return betTypes;
+};
+
+export const getLeagueTotalTypes = (league: League, leagueInfoArray: LeagueConfigInfo[]) => {
+    const betTypes = leagueInfoArray
+        .filter(
+            (leagueInfo) =>
+                Number(leagueInfo.sportId) === Number(league) &&
+                leagueInfo.type === 'Total' &&
+                leagueInfo.enabled === 'true'
+        )
+        .map((leagueInfo) => leagueInfo.marketName.toLowerCase());
+
+    return betTypes;
+};

package/src/utils/spread.ts

@@ -1,97 +1,97 @@
-import { LeagueConfigInfo } from '../types/sports';
-
-export const adjustSpreadOnOdds = (impliedProbs: number[], minSpread: number, targetSpread: number) => {
-    // Step 1: Check if any implied probability is zero
-    if (impliedProbs.some((prob) => prob === 0)) {
-        return impliedProbs;
-    }
-
-    // Step 2: Calculate the current total implied probabilities
-    const totalImpliedProbs = impliedProbs.reduce((sum, prob) => sum + prob, 0);
-
-    // Step 3: Check if the sum of implied probabilities is greater than 1
-    if (totalImpliedProbs <= 1) {
-        return Array(impliedProbs.length).fill(0);
-    }
-
-    // Step 4: Check if targetSpread is zero
-    if (targetSpread === 0) {
-        const currentSpread = (totalImpliedProbs - 1) * 100;
-        // If minSpread is set and greater than current spread, use minSpread
-        if (minSpread > currentSpread) {
-            targetSpread = minSpread;
-        } else {
-            // If minSpread is less than current spread, return odds as they are
-            return impliedProbs;
-        }
-    }
-
-    // Step 5: Calculate the target total implied probabilities
-    const targetTotalImpliedProbs = 1 + targetSpread / 100;
-
-    // Step 6: Calculate the adjustment factor
-    const adjustmentFactor = targetTotalImpliedProbs / totalImpliedProbs;
-
-    // Step 7: Adjust the probabilities to reflect the target spread
-    let adjustedImpliedProbs = impliedProbs.map((prob) => prob * adjustmentFactor);
-
-    // Step 8: Check if any adjusted probability equals or exceeds 1
-    if (adjustedImpliedProbs.some((prob) => prob >= 1)) {
-        return Array(impliedProbs.length).fill(0);
-    }
-
-    // Step 9: Ensure the sum of the adjusted probabilities equals the target total implied probabilities
-    const sumAdjustedProbs = adjustedImpliedProbs.reduce((sum, prob) => sum + prob, 0);
-
-    // Step 10: If the sum of the adjusted probabilities is less than 1, return zeros
-    if (sumAdjustedProbs < 1) {
-        return Array(impliedProbs.length).fill(0);
-    }
-
-    const normalizationFactor = targetTotalImpliedProbs / sumAdjustedProbs;
-    adjustedImpliedProbs = adjustedImpliedProbs.map((prob) => prob * normalizationFactor);
-
-    return adjustedImpliedProbs;
-};
-
-export const getSpreadData = (
-    spreadData: any[],
-    sportId: string,
-    typeId: number,
-    defaultSpreadForLiveMarkets: number
-) => {
-    const sportSpreadData = spreadData.find(
-        (data) => Number(data.typeId) === Number(typeId) && Number(data.sportId) === Number(sportId)
-    );
-    if (sportSpreadData) {
-        return {
-            minSpread: sportSpreadData.minSpread ? Number(sportSpreadData.minSpread) : defaultSpreadForLiveMarkets,
-            targetSpread: sportSpreadData.targetSpread ? Number(sportSpreadData.targetSpread) : 0,
-        };
-    }
-    return { minSpread: defaultSpreadForLiveMarkets, targetSpread: 0 };
-};
-
-export const adjustAddedSpread = (odds: number[], leagueInfo: LeagueConfigInfo[], typeId: number) => {
-    // Pack market odds for UI
-    return odds.map((probability) => {
-        if (probability != 0) {
-            const leagueInfoByTypeId = leagueInfo.find((league) => Number(league.typeId) === Number(typeId));
-            let finalProbability = probability;
-
-            if (probability < 0.95) {
-                if (leagueInfoByTypeId && Number(leagueInfoByTypeId.addedSpread)) {
-                    finalProbability = (probability * (100 + Number(leagueInfoByTypeId.addedSpread))) / 100;
-                    // edge case if added spread is bigger than 5%, it can happen that odd goes above 1, in that case return odd from api.
-                    if (finalProbability >= 1) {
-                        finalProbability = probability;
-                    }
-                }
-            }
-
-            return finalProbability;
-        } else {
-            return 0;
-        }
-    });
-};
+import { LeagueConfigInfo } from '../types/sports';
+
+export const adjustSpreadOnOdds = (impliedProbs: number[], minSpread: number, targetSpread: number) => {
+    // Step 1: Check if any implied probability is zero
+    if (impliedProbs.some((prob) => prob === 0)) {
+        return impliedProbs;
+    }
+
+    // Step 2: Calculate the current total implied probabilities
+    const totalImpliedProbs = impliedProbs.reduce((sum, prob) => sum + prob, 0);
+
+    // Step 3: Check if the sum of implied probabilities is greater than 1
+    if (totalImpliedProbs <= 1) {
+        return Array(impliedProbs.length).fill(0);
+    }
+
+    // Step 4: Check if targetSpread is zero
+    if (targetSpread === 0) {
+        const currentSpread = (totalImpliedProbs - 1) * 100;
+        // If minSpread is set and greater than current spread, use minSpread
+        if (minSpread > currentSpread) {
+            targetSpread = minSpread;
+        } else {
+            // If minSpread is less than current spread, return odds as they are
+            return impliedProbs;
+        }
+    }
+
+    // Step 5: Calculate the target total implied probabilities
+    const targetTotalImpliedProbs = 1 + targetSpread / 100;
+
+    // Step 6: Calculate the adjustment factor
+    const adjustmentFactor = targetTotalImpliedProbs / totalImpliedProbs;
+
+    // Step 7: Adjust the probabilities to reflect the target spread
+    let adjustedImpliedProbs = impliedProbs.map((prob) => prob * adjustmentFactor);
+
+    // Step 8: Check if any adjusted probability equals or exceeds 1
+    if (adjustedImpliedProbs.some((prob) => prob >= 1)) {
+        return Array(impliedProbs.length).fill(0);
+    }
+
+    // Step 9: Ensure the sum of the adjusted probabilities equals the target total implied probabilities
+    const sumAdjustedProbs = adjustedImpliedProbs.reduce((sum, prob) => sum + prob, 0);
+
+    // Step 10: If the sum of the adjusted probabilities is less than 1, return zeros
+    if (sumAdjustedProbs < 1) {
+        return Array(impliedProbs.length).fill(0);
+    }
+
+    const normalizationFactor = targetTotalImpliedProbs / sumAdjustedProbs;
+    adjustedImpliedProbs = adjustedImpliedProbs.map((prob) => prob * normalizationFactor);
+
+    return adjustedImpliedProbs;
+};
+
+export const getSpreadData = (
+    spreadData: any[],
+    sportId: string,
+    typeId: number,
+    defaultSpreadForLiveMarkets: number
+) => {
+    const sportSpreadData = spreadData.find(
+        (data) => Number(data.typeId) === Number(typeId) && Number(data.sportId) === Number(sportId)
+    );
+    if (sportSpreadData) {
+        return {
+            minSpread: sportSpreadData.minSpread ? Number(sportSpreadData.minSpread) : defaultSpreadForLiveMarkets,
+            targetSpread: sportSpreadData.targetSpread ? Number(sportSpreadData.targetSpread) : 0,
+        };
+    }
+    return { minSpread: defaultSpreadForLiveMarkets, targetSpread: 0 };
+};
+
+export const adjustAddedSpread = (odds: number[], leagueInfo: LeagueConfigInfo[], typeId: number) => {
+    // Pack market odds for UI
+    return odds.map((probability) => {
+        if (probability != 0) {
+            const leagueInfoByTypeId = leagueInfo.find((league) => Number(league.typeId) === Number(typeId));
+            let finalProbability = probability;
+
+            if (probability < 0.95) {
+                if (leagueInfoByTypeId && Number(leagueInfoByTypeId.addedSpread)) {
+                    finalProbability = (probability * (100 + Number(leagueInfoByTypeId.addedSpread))) / 100;
+                    // edge case if added spread is bigger than 5%, it can happen that odd goes above 1, in that case return odd from api.
+                    if (finalProbability >= 1) {
+                        finalProbability = probability;
+                    }
+                }
+            }
+
+            return finalProbability;
+        } else {
+            return 0;
+        }
+    });
+};

package/tsconfig.json

@@ -1,17 +1,17 @@
-{
-    "compilerOptions": {
-        "module": "esnext",
-        "esModuleInterop": true,
-        "target": "es5",
-        "lib": [
-            "dom",
-            "dom.iterable",
-            "esnext"
-        ],
-        "moduleResolution": "node",
-        "sourceMap": true,
-        "outDir": "build",
-        "declaration": true,
-        "strict": true,
-    }
+{
+    "compilerOptions": {
+        "module": "esnext",
+        "esModuleInterop": true,
+        "target": "ESNext",
+        "lib": [
+            "dom",
+            "dom.iterable",
+            "esnext"
+        ],
+        "moduleResolution": "node",
+        "sourceMap": true,
+        "outDir": "build",
+        "declaration": true,
+        "strict": true,
+    }
 }

package/webpack.config.js

@@ -1,24 +1,24 @@
-const path = require('path');
-
-module.exports = {
-    entry: './index.ts',
-    module: {
-        rules: [
-            {
-                test: /\.ts?$/,
-                use: 'ts-loader',
-                exclude: /node_modules/,
-            },
-        ],
-    },
-    resolve: {
-        extensions: ['.tsx', '.ts', '.js'],
-    },
-    output: {
-        filename: 'main.js',
-        path: path.resolve(__dirname),
-        library: 'thalesUtils',
-        libraryTarget: 'umd',
-        globalObject: 'this',
-    },
-};
+const path = require('path');
+
+module.exports = {
+    entry: './index.ts',
+    module: {
+        rules: [
+            {
+                test: /\.ts?$/,
+                use: 'ts-loader',
+                exclude: /node_modules/,
+            },
+        ],
+    },
+    resolve: {
+        extensions: ['.tsx', '.ts', '.js'],
+    },
+    output: {
+        filename: 'main.js',
+        path: path.resolve(__dirname),
+        library: 'thalesUtils',
+        libraryTarget: 'umd',
+        globalObject: 'this',
+    },
+};

package/CLAUDE.md

@@ -1,84 +0,0 @@
-# CLAUDE.md
-
-This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
-
-## Project Overview
-
-This is a TypeScript utility library for live sports betting/trading. It processes odds data from multiple bookmakers, applies spreads, validates odds consistency, and generates child markets for various bet types (moneyline, spreads, totals). The library is designed to work with the Overtime sports betting platform.
-
-## Commands
-
-### Build & Compile
-
--   `npm run compile` - Compile TypeScript to JavaScript
--   `npm run pack` - Build production bundle with webpack
-
-### Testing
-
--   `npm test` - Run all Jest tests
--   `npm test -- --coverage` - Run tests with coverage report
--   `npm test -- src/tests/unit/odds.test.ts` - Run a specific test file
-
-### Development
-
-The library is published to npm. Run `npm run prepublish` to pack before publishing (runs automatically on npm publish).
-
-## Architecture
-
-### Core Processing Flow
-
-The main processing pipeline:
-
-1. **Bookmaker Selection** (`src/utils/bookmakers.ts`) - Selects primary/secondary/tertiary bookmakers for a sport, validates odds consistency across providers
-2. **Odds Processing** (`src/utils/odds.ts`) - Converts odds formats (decimal ↔ implied probability), filters by market type and bookmaker, creates parent moneyline odds
-3. **Spread Adjustment** (`src/utils/spread.ts`) - Applies spread data to odds, handles Asian handicap, game/point/goal spreads, run/puck lines
-4. **Market Generation** (`src/utils/markets.ts`) - Main `processMarket()` function orchestrates the pipeline: gets moneyline odds → applies spread → creates child markets
-5. **Child Markets** (`src/utils/odds.ts`) - Generates derivative markets (spreads, totals, double chance, correct score) from parent moneyline odds
-
-### Key Concepts
-
-**League Configuration**: Each league (sport) has a configuration defining enabled bet types, min/max odds, and added spreads. The `LeagueConfigInfo` type stores this data, typically loaded from CSV files like `live-markets-map.csv`.
-
-**Two vs Three-Positional Sports**: The library distinguishes between sports with 2 positions (tennis, esports - no draw) and 3 positions (soccer, hockey - draw possible). This affects odds validation and market generation.
-
-**Odds Validation**: The `checkOddsFromBookmakers()` function compares odds from multiple bookmakers using implied probability differences to detect discrepancies that might indicate stale or incorrect data.
-
-**OpticOdds Integration**: `src/utils/opticOdds.ts` provides utilities for working with the OpticOdds API format, including filtering odds by market name/bookmaker and handling team name matching.
-
-### Type System
-
-Key types in `src/types/`:
-
--   `OddsObject` - Complete game data with odds array from API
--   `Odds` - Array of individual odds entries with bookmaker, price, market name
--   `LeagueConfigInfo` - League/market configuration (enabled status, min/max odds, spread)
--   `ChildMarket` - Generated derivative market with line and odds
--   `Fixture` & `ScoresObject` - Game metadata and live scores
-
-### Sports-Specific Logic
-
-`src/constants/sports.ts` defines leagues without formal home/away designation (esports, tennis). `src/enums/sports.ts` defines comprehensive tennis subleague mappings and market type enums (`MoneylineTypes`, `SpreadTypes`, `TotalTypes`).
-
-### Error Handling
-
-Error messages in `src/constants/errors.ts`:
-
--   `NO_MATCHING_BOOKMAKERS_MESSAGE` - None of the specified bookmakers have odds
--   `DIFF_BETWEEN_BOOKMAKERS_MESSAGE` - Bookmaker odds diverge beyond threshold
--   `ZERO_ODDS_MESSAGE` - Zero odds detected (invalid)
--   `ZERO_ODDS_AFTER_SPREAD_ADJUSTMENT` - Spread adjustment resulted in zero odds
-
-## Testing Notes
-
-Tests use mock data from `src/tests/mock/`:
-
--   `MockLeagueMap.ts` - League configuration fixtures
--   `MockOpticSoccer.ts` - Sample OpticOdds API responses
--   `MockSoccerRedis.ts` - Redis-cached odds data
-
-Test files are organized by utility module: `odds.test.ts`, `sports.test.ts`, `spread.test.ts`, `markets.test.ts`, `bookmakers.test.ts`.
-
-## Dependencies
-
--   `oddslib` - Odds format conversion (decimal, moneyline, implied probability)
--   `overtime-utils` - Shared types and enums for the Overtime platform (League enum, MarketType)