overtime-utils 0.1.74-rc.0 → 0.1.74

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "overtime-utils",
-    "version": "0.1.74-rc.0",
+    "version": "0.1.74",
     "description": "",
     "main": "main.js",
     "scripts": {

package/src/constants/marketTypes.ts

@@ -3836,7 +3836,6 @@ export const MarketTypeMap: Record<MarketType, MarketTypeInfo> = {
         name: 'Total fouls',
         resultType: ResultType.OVER_UNDER,
     },
-
 };
 
 export const WINNER_MARKET_TYPES = [
@@ -4431,6 +4430,7 @@ export const PLAYER_PROPS_MARKET_TYPES = [
     MarketType.PLAYER_PROPS_MAN_OF_THE_MATCH,
     MarketType.PLAYER_PROPS_WICKETS_TAKEN,
     MarketType.PLAYER_PROPS_SIXES,
+    MarketType.PLAYER_PROPS_FOURS,
     MarketType.PLAYER_PROPS_THREE_DART_AVERAGE,
     MarketType.PLAYER_PROPS_180,
     MarketType.PLAYER_PROPS_100_PLUS_CHECKOUTS,

package/src/utils/odds.ts

@@ -1,579 +0,0 @@
-const ZERO = 0;
-const MULTIPLIER_100 = 100;
-const MINIMAL_PROBABILITY_SUM = 1.02;
-
-const log = (...args: any[]) => {
-    const isTest = process.env.NODE_ENV === 'test';
-    if (isTest) {
-        console.log(...args);
-    }
-};
-
-/**
- * Checks if the sum of odds is greater than MINIMAL_PROBABILITY_SUM.
- * @param {Array<number>} odds - Array of odds.
- * @returns {{ odds: Array<number>, isValid: boolean, sumOfOdds: number }}
- *          - odds: adjusted odds or array of zeros
- *          - isValid: true if sum >= MINIMAL_PROBABILITY_SUM, false otherwise
- *          - sumOfOdds: sum of all odds
- */
-function checkOddsIfGreaterThanMinimalSum(
-    odds: number[],
-    minimal = MINIMAL_PROBABILITY_SUM
-): { odds: Array<number>; isValid: boolean; sumOfOdds: number } {
-    const sumOfOdds = odds.reduce((sum, odd) => sum + odd, ZERO);
-    const isValid = sumOfOdds >= minimal;
-
-    if (!isValid) {
-        log('Odds sum invalid: sum=%s, expected >= %s, odds=%o -> returning zeros.', sumOfOdds, minimal, odds);
-    }
-
-    return {
-        odds: isValid ? odds : new Array(odds.length).fill(ZERO),
-        isValid,
-        sumOfOdds,
-    };
-}
-
-/**
- * Rebalances the given odds based on provided cap and risk values for two positions.
- *
- * @param {Array<number>} currentOddsArray - The array of odds to be rebalanced.
- * @param {number} cap - The cap value used for adjustments.
- * @param {number} positionOneRisk - The risk adjustment for position one.
- * @param {number} positionTwoRisk - The risk adjustment for position two.
- * @param {number} [lowerPercentageRisk=33]   - The lower percentage risk threshold.
- * @param {number} [middlePercentageRisk=50]  - The middle percentage risk threshold.
- * @param {number} [higherPercentageRisk=66]  - The higher percentage risk threshold.
- * @param {number} [lowerPercentageRiskRebalance=1]   - Rebalance % when in (lower, middle].
- * @param {number} [middlePercentageRiskRebalance=1.5]- Rebalance % when in (middle, higher].
- * @param {number} [higherPercentageRiskRebalance=2]  - Rebalance % when > higher.
- * @param {boolean} [rebalanceOnRiskSideOnly=true] - If true, only the higher-risk side is boosted and
- *        the other side is left as-is; if false, the opposite side is reduced as well.
- * @returns {{ odds: number[], isRebalanced: boolean, minPercantage: number, adjustedPercantage: number }}
- */
-function rebalanceOdds(
-    currentOddsArray: number[],
-    cap: number,
-    positionOneRisk: number,
-    positionTwoRisk: number,
-    lowerPercentageRisk: number = 33,
-    middlePercentageRisk: number = 50,
-    higherPercentageRisk: number = 66,
-    lowerPercentageRiskRebalance: number = 1, // %
-    middlePercentageRiskRebalance: number = 1.5, // %
-    higherPercentageRiskRebalance: number = 2, // %
-    rebalanceOnRiskSideOnly: boolean = true
-): { odds: number[]; isRebalanced: boolean; minPercantage: number; adjustedPercantage: number } {
-    // Validate input
-    if (!Array.isArray(currentOddsArray) || currentOddsArray.length !== 2) {
-        log('Invalid odds array. Returning [0, 0].');
-        return {
-            odds: [ZERO, ZERO],
-            isRebalanced: false,
-            minPercantage: 0,
-            adjustedPercantage: 0,
-        };
-    }
-
-    if (cap <= ZERO) {
-        log('Invalid cap value. Returning current odds.');
-        return {
-            odds: currentOddsArray,
-            isRebalanced: false,
-            minPercantage: 0,
-            adjustedPercantage: 0,
-        };
-    }
-
-    const [odds1, odds2] = currentOddsArray;
-
-    // Check if odds are within valid range
-    if (odds1 <= ZERO || odds1 >= 1 || odds2 <= ZERO || odds2 >= 1 || odds1 + odds2 <= 1) {
-        log('Invalid odds: either individual odds are out of range or their sum is less than 1. Returning [0, 0].');
-        return {
-            odds: [ZERO, ZERO],
-            isRebalanced: false,
-            minPercantage: 0,
-            adjustedPercantage: 0,
-        };
-    }
-
-    // Find the maximum risk and its associated position
-    const maxRisk = Math.max(positionOneRisk, positionTwoRisk);
-    const riskPercentage = (Math.abs(maxRisk) / cap) * MULTIPLIER_100;
-
-    log('Max Risk: %s, Risk Percentage: %s%%', maxRisk, riskPercentage);
-
-    // Determine the adjustment factor
-    let adjustment = ZERO;
-    if (riskPercentage > lowerPercentageRisk && riskPercentage <= middlePercentageRisk) {
-        adjustment = lowerPercentageRiskRebalance / MULTIPLIER_100;
-    } else if (riskPercentage > middlePercentageRisk && riskPercentage <= higherPercentageRisk) {
-        adjustment = middlePercentageRiskRebalance / MULTIPLIER_100;
-    } else if (riskPercentage > higherPercentageRisk) {
-        adjustment = higherPercentageRiskRebalance / MULTIPLIER_100;
-    }
-
-    // If no adjustment is needed, return the current odds
-    if (adjustment === ZERO) {
-        log('Risk percentage is within acceptable limits. No rebalancing needed. Current odds: %o', currentOddsArray);
-        return {
-            odds: currentOddsArray,
-            isRebalanced: false,
-            minPercantage: 0,
-            adjustedPercantage: 0,
-        };
-    }
-
-    // Log original odds before rebalancing
-    log('Original Odds: [%s, %s]', odds1, odds2);
-
-    // Adjust the odds by multiplying with (1 ± adjustment)
-    let newOdds1, newOdds2;
-
-    if (maxRisk === positionOneRisk) {
-        newOdds1 = odds1 * (1 + adjustment); // Increase odds1
-        // do not change or decrease odds2 depending on a rebalanceOnRiskSideOnly flag
-        newOdds2 = rebalanceOnRiskSideOnly ? odds2 : odds2 * (1 - adjustment);
-    } else {
-        // do not change or decrease odds1 depending on a rebalanceOnRiskSideOnly flag
-        newOdds1 = rebalanceOnRiskSideOnly ? odds1 : odds1 * (1 - adjustment);
-        newOdds2 = odds2 * (1 + adjustment); // Increase odds2
-    }
-
-    log('Rebalanced Odds: [%s, %s]', newOdds1, newOdds2);
-
-    // Check if rebalanced odds are valid
-    const { odds: sumCheckedOdds, isValid, sumOfOdds } = checkOddsIfGreaterThanMinimalSum([newOdds1, newOdds2]);
-
-    // Check if rebalanced odds are valid
-    if (newOdds1 <= ZERO || newOdds2 <= ZERO || newOdds1 >= 1 || newOdds2 >= 1 || !isValid) {
-        log(
-            'Rebalanced odds invalid: sum=%s, expected >= %s, odds=[%s, %s] -> returning [0, 0].',
-            sumOfOdds,
-            MINIMAL_PROBABILITY_SUM,
-            newOdds1,
-            newOdds2
-        );
-        return {
-            odds: [ZERO, ZERO],
-            isRebalanced: false,
-            minPercantage: 0,
-            adjustedPercantage: 0,
-        };
-    }
-
-    // Return valid rebalanced odds
-    return {
-        odds: sumCheckedOdds,
-        isRebalanced: true,
-        minPercantage: lowerPercentageRisk,
-        adjustedPercantage: riskPercentage,
-    };
-}
-
-/**
- * Rebalances multi-way (≥3) implied odds by shifting probability toward the
- * highest-risk position and reducing the rest (implicitly via sum check).
- *
- * @param {number[]} currentOddsArray - Implied probabilities per position (each in (0,1)), N ≥ 3.
- * @param {number} cap - Absolute cap used to normalize risk to percentage (must be > 0).
- * @param {number[]} positionRisks - Risks per position; only first N used; missing padded with 0.
- * @param {number} [lowerPercentageRisk=33]  - Lower risk % threshold.
- * @param {number} [middlePercentageRisk=50] - Middle risk % threshold.
- * @param {number} [higherPercentageRisk=66] - Higher risk % threshold.
- * @param {number} [lowerPercentageRiskRebalance=1]   - % increase when in (lower, middle].
- * @param {number} [middlePercentageRiskRebalance=1.5]- % increase when in (middle, higher].
- * @param {number} [higherPercentageRiskRebalance=2]  - % increase when > higher.
- * @param {boolean} [rebalanceOnRiskSideOnly=true] - If true, only the highest-risk side is boosted and
- *        all other positions stay unchanged. If false, other positions are slightly reduced so that
- *        the overall probability mass is approximately conserved.
- * @returns {{ odds: number[], isRebalanced: boolean, minPercantage: number, adjustedPercantage: number }} Rebalanced odds and flag.
- */
-function rebalanceMultiOdds(
-    currentOddsArray: number[],
-    cap: number,
-    positionRisks: number[],
-    lowerPercentageRisk: number = 33,
-    middlePercentageRisk: number = 50,
-    higherPercentageRisk: number = 66,
-    lowerPercentageRiskRebalance: number = 1, // %
-    middlePercentageRiskRebalance: number = 1.5, // %
-    higherPercentageRiskRebalance: number = 2, // %
-    rebalanceOnRiskSideOnly: boolean = true
-): { odds: number[]; isRebalanced: boolean; minPercantage: number; adjustedPercantage: number } {
-    // Basic validation
-    if (!Array.isArray(currentOddsArray)) {
-        log('Invalid odds array (not an array). Returning zeros.');
-        return {
-            odds: new Array(3).fill(ZERO), // same behavior as before when not an array
-            isRebalanced: false,
-            minPercantage: 0,
-            adjustedPercantage: 0,
-        };
-    }
-
-    if (currentOddsArray.length < 3) {
-        log('Multi-way rebalancing needs >= 3 positions. Returning current odds.');
-        return {
-            odds: currentOddsArray,
-            isRebalanced: false,
-            minPercantage: 0,
-            adjustedPercantage: 0,
-        };
-    }
-
-    if (cap <= ZERO) {
-        log('Invalid cap value. Returning current odds.');
-        return {
-            odds: currentOddsArray,
-            isRebalanced: false,
-            minPercantage: 0,
-            adjustedPercantage: 0,
-        };
-    }
-
-    const N = currentOddsArray.length;
-
-    const sum = currentOddsArray.reduce((s, o) => s + o, ZERO);
-    if (currentOddsArray.some((o) => o < ZERO || o >= 1) || sum <= 1) {
-        log('Invalid odds for multi-way. Returning zeros.');
-        return {
-            odds: new Array(N).fill(ZERO),
-            isRebalanced: false,
-            minPercantage: 0,
-            adjustedPercantage: 0,
-        };
-    }
-
-    // Use risks for the first N positions (pad with 0)
-    const risks = Array.from({ length: N }, (_, i) => Number(positionRisks?.[i] ?? ZERO));
-
-    // Find index of max risk (consistent with 2-way: Math.max, then abs() for %)
-    let maxIdx = 0;
-    for (let i = 1; i < N; i++) if (risks[i] > risks[maxIdx]) maxIdx = i;
-    const maxRisk = risks[maxIdx];
-    const riskPercentage = (Math.abs(maxRisk) / cap) * MULTIPLIER_100;
-
-    let adjustment = ZERO;
-    if (riskPercentage > lowerPercentageRisk && riskPercentage <= middlePercentageRisk) {
-        adjustment = lowerPercentageRiskRebalance / MULTIPLIER_100;
-    } else if (riskPercentage > middlePercentageRisk && riskPercentage <= higherPercentageRisk) {
-        adjustment = middlePercentageRiskRebalance / MULTIPLIER_100;
-    } else if (riskPercentage > higherPercentageRisk) {
-        adjustment = higherPercentageRiskRebalance / MULTIPLIER_100;
-    }
-
-    if (adjustment === ZERO) {
-        log('Risk %% within limits (multi-way). No rebalancing. Current odds: %o', currentOddsArray);
-        return {
-            odds: currentOddsArray,
-            isRebalanced: false,
-            minPercantage: 0,
-            adjustedPercantage: 0,
-        };
-    }
-
-    const downFactor = adjustment / (N - 1); // e.g., +2% on one => -1% on each of two
-    const newOdds = currentOddsArray.map((o, i) => {
-        if (i === maxIdx) return o * (1 + adjustment);
-        if (rebalanceOnRiskSideOnly) return o;
-        return o * (1 - downFactor);
-    });
-
-    // Validate new odds using the helper
-    const { odds: sumCheckedOdds, isValid, sumOfOdds } = checkOddsIfGreaterThanMinimalSum(newOdds);
-
-    // fail only on negatives or failed sum check
-    if (newOdds.some((o) => o < ZERO) || !isValid) {
-        log(
-            'Rebalanced multi-way odds invalid: sum=%s, expected >= %s, odds=%o -> returning zeros.',
-            sumOfOdds,
-            MINIMAL_PROBABILITY_SUM,
-            newOdds
-        );
-        return {
-            odds: new Array(N).fill(ZERO),
-            isRebalanced: false,
-            minPercantage: 0,
-            adjustedPercantage: 0,
-        };
-    }
-
-    // valid → clamp any >= 1 to 0 (don’t revalidate)
-    const overOneIdx: number[] = [];
-    const finalOdds = sumCheckedOdds.map((o, i) => {
-        if (o >= 1) {
-            overOneIdx.push(i);
-            return ZERO;
-        }
-        return o;
-    });
-    if (overOneIdx.length) {
-        log('Odds >= 1 found at indexes %o; set to 0.', overOneIdx);
-    }
-
-    return {
-        odds: finalOdds,
-        isRebalanced: true,
-        minPercantage: lowerPercentageRisk,
-        adjustedPercantage: riskPercentage,
-    };
-}
-
-/**
- * Adjusts a single odds value based on risk exposure and predefined rebalancing thresholds.
- *
- * @param {number[]} currentOdds - An array containing a single odds value to be rebalanced.
- * @param {number} cap - The maximum risk exposure allowed.
- * @param {number} risk - The risk associated with the odds position.
- * @param {number} [lowerPercentageRisk=33]  - Lower threshold.
- * @param {number} [middlePercentageRisk=50] - Middle threshold.
- * @param {number} [higherPercentageRisk=66] - Higher threshold.
- * @param {number} [lowerPercentageRiskRebalance=1]   - % when in (lower, middle].
- * @param {number} [middlePercentageRiskRebalance=1.5]- % when in (middle, higher].
- * @param {number} [higherPercentageRiskRebalance=2]  - % when > higher.
- * @returns {{ odds: number[], isRebalanced: boolean, minPercantage: number, adjustedPercantage: number }}
- */
-function rebalanceSingleOdd(
-    currentOdds: number[],
-    cap: number,
-    risk: number,
-    lowerPercentageRisk: number = 33,
-    middlePercentageRisk: number = 50,
-    higherPercentageRisk: number = 66,
-    lowerPercentageRiskRebalance: number = 1, // %
-    middlePercentageRiskRebalance: number = 1.5, // %
-    higherPercentageRiskRebalance: number = 2 // %
-): { odds: number[]; isRebalanced: boolean; minPercantage: number; adjustedPercantage: number } {
-    // Validate input
-    if (!Array.isArray(currentOdds) || currentOdds.length !== 1) {
-        log('Invalid odds input. Expected an array with one element. Returning [ZERO].');
-        return {
-            odds: [ZERO],
-            isRebalanced: false,
-            minPercantage: 0,
-            adjustedPercantage: 0,
-        };
-    }
-
-    const [odd] = currentOdds;
-
-    if (odd <= ZERO || odd >= 1) {
-        log('Invalid odd value. Returning [ZERO].');
-        return {
-            odds: [ZERO],
-            isRebalanced: false,
-            minPercantage: 0,
-            adjustedPercantage: 0,
-        };
-    }
-
-    if (cap <= ZERO) {
-        log('Invalid cap value. Returning current odds.');
-        return {
-            odds: currentOdds,
-            isRebalanced: false,
-            minPercantage: 0,
-            adjustedPercantage: 0,
-        };
-    }
-
-    // Calculate risk percentage
-    const riskPercentage = (Math.abs(risk) / cap) * MULTIPLIER_100;
-
-    log('Risk: %s, Risk Percentage: %s%%', risk, riskPercentage);
-
-    // Determine the adjustment factor
-    let adjustment = ZERO;
-    if (riskPercentage > lowerPercentageRisk && riskPercentage <= middlePercentageRisk) {
-        adjustment = lowerPercentageRiskRebalance / MULTIPLIER_100;
-    } else if (riskPercentage > middlePercentageRisk && riskPercentage <= higherPercentageRisk) {
-        adjustment = middlePercentageRiskRebalance / MULTIPLIER_100;
-    } else if (riskPercentage > higherPercentageRisk) {
-        adjustment = higherPercentageRiskRebalance / MULTIPLIER_100;
-    }
-
-    // If no adjustment is needed, return the current odds
-    if (adjustment === ZERO) {
-        log('No rebalancing needed. Current odds: %o', currentOdds);
-        return {
-            odds: currentOdds,
-            isRebalanced: false,
-            minPercantage: 0,
-            adjustedPercantage: 0,
-        };
-    }
-
-    // Log original odds before rebalancing
-    log('Original Odds: %s', odd);
-
-    // Adjust the odd based on risk direction (only positive adjustment)
-    let newOdd = odd;
-    let isRebalanced = false;
-    if (risk >= ZERO) {
-        newOdd = odd * (1 + adjustment);
-        isRebalanced = true;
-    }
-
-    log('Rebalanced Odd: %s', newOdd);
-
-    // Validate rebalanced odd
-    if (newOdd <= ZERO || newOdd >= 1) {
-        log('Rebalanced odd is invalid (out of range). Returning [ZERO].');
-        return {
-            odds: [ZERO],
-            isRebalanced: false,
-            minPercantage: 0,
-            adjustedPercantage: 0,
-        };
-    }
-
-    return {
-        odds: [newOdd],
-        isRebalanced,
-        minPercantage: lowerPercentageRisk,
-        adjustedPercantage: riskPercentage,
-    };
-}
-
-/**
- * Rebalances odds based on risk data for a specific type ID.
- *
- * @param {Array<number>} currentOddsArray - The array of odds to be rebalanced.
- * @param {number} typeId - The type ID used to filter risk data.
- * @param {Object} riskData - The risk data object containing risk information.
- * @param {number|null} [playerId=null] - Optional player ID for player-specific risk filtering.
- * @returns {{ odds: number[], isRebalanced: boolean, minPercantage: number, adjustedPercantage: number }} - The rebalanced odds array and a flag indicating whether rebalancing was applied.
- */
-export function rebalanceOddsBasedOnRisk(
-    currentOddsArray: number[],
-    typeId: number,
-    riskData: { fileExists: boolean; riskObject: any[] },
-    playerId: number | null = null
-): { odds: number[]; isRebalanced: boolean; minPercantage: number; adjustedPercantage: number } {
-    // Step 1: Check if riskData is missing or invalid
-    if (!riskData || !riskData.fileExists || !Array.isArray(riskData.riskObject)) {
-        log('Invalid or missing risk data. Return odds as it is.');
-        return {
-            odds: currentOddsArray,
-            isRebalanced: false,
-            minPercantage: 0,
-            adjustedPercantage: 0,
-        };
-    }
-
-    // Step 2: Find risk configuration for the given typeId (and playerId if provided)
-    const filteredRisk = riskData.riskObject.find(
-        (entry) => entry.typeId === typeId && (playerId === null || entry.playerId === Number(playerId))
-    );
-
-    if (!filteredRisk) {
-        log(
-            'No risk entry found for typeId: %s%s. Returning original odds array: %o',
-            typeId,
-            playerId !== null && playerId !== undefined ? ` and playerId: ${playerId}` : '',
-            currentOddsArray
-        );
-        return {
-            odds: currentOddsArray,
-            isRebalanced: false,
-            minPercantage: 0,
-            adjustedPercantage: 0,
-        };
-    }
-
-    // Step 3: Validate the odds array
-    if (!Array.isArray(currentOddsArray)) {
-        log('Invalid odds array. Returning all zeros.');
-        return {
-            odds: new Array(filteredRisk.numberOfPositions).fill(ZERO),
-            isRebalanced: false,
-            minPercantage: 0,
-            adjustedPercantage: 0,
-        };
-    }
-
-    const oddsLength = currentOddsArray.length;
-
-    // Step 4: Check the total implied probability
-    const { odds: adjustedOdds, isValid, sumOfOdds } = checkOddsIfGreaterThanMinimalSum(currentOddsArray);
-
-    if (!isValid && adjustedOdds.length > 1) {
-        log(
-            'Total implied probabilities too low: sum=%s, expected >= %s. Odds=%o -> returning zeros.',
-            sumOfOdds,
-            MINIMAL_PROBABILITY_SUM,
-            currentOddsArray
-        );
-        return {
-            odds: new Array(oddsLength).fill(ZERO),
-            isRebalanced: false,
-            minPercantage: 0,
-            adjustedPercantage: 0,
-        };
-    }
-
-    // Step 4: Extract risk values
-    const {
-        cap,
-        positionRisk = [],
-        lowerPercentageRisk,
-        middlePercentageRisk,
-        higherPercentageRisk,
-        lowerPercentageRiskRebalance,
-        middlePercentageRiskRebalance,
-        higherPercentageRiskRebalance,
-        rebalanceOnRiskSideOnly,
-    } = filteredRisk;
-
-    // Step 5: Handle one-positional, two-positional, or multi-positional odds
-    if (oddsLength === 2) {
-        log('Rebalancing two-positional odds for typeId: %s', typeId);
-        return rebalanceOdds(
-            currentOddsArray,
-            cap,
-            Number(positionRisk[0] ?? ZERO),
-            Number(positionRisk[1] ?? ZERO),
-            lowerPercentageRisk,
-            middlePercentageRisk,
-            higherPercentageRisk,
-            lowerPercentageRiskRebalance,
-            middlePercentageRiskRebalance,
-            higherPercentageRiskRebalance,
-            rebalanceOnRiskSideOnly
-        );
-    } else if (oddsLength === 1) {
-        log('Rebalancing single odd for typeId: %s', typeId);
-        return rebalanceSingleOdd(
-            currentOddsArray,
-            cap,
-            Number(positionRisk[0] ?? ZERO),
-            lowerPercentageRisk,
-            middlePercentageRisk,
-            higherPercentageRisk,
-            lowerPercentageRiskRebalance,
-            middlePercentageRiskRebalance,
-            higherPercentageRiskRebalance
-        );
-    }
-
-    // Step 7: Handle N-positional odds
-    log('Rebalancing %d-positional odds for typeId: %s', oddsLength, typeId);
-
-    const positionRisks = Array.from({ length: oddsLength }, (_, i) => Number(positionRisk[i] ?? ZERO));
-
-    return rebalanceMultiOdds(
-        currentOddsArray,
-        cap,
-        positionRisks,
-        lowerPercentageRisk,
-        middlePercentageRisk,
-        higherPercentageRisk,
-        lowerPercentageRiskRebalance,
-        middlePercentageRiskRebalance,
-        higherPercentageRiskRebalance,
-        rebalanceOnRiskSideOnly
-    );
-}