overtime-live-trading-utils 2.1.44 → 2.1.45

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": "es5",
+        "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',
+    },
+};