overtime-utils 0.1.74 → 0.1.75

package/package.json

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

package/src/utils/odds.ts

@@ -0,0 +1,580 @@
+const ZERO = 0;
+const MULTIPLIER_100 = 100;
+const MINIMAL_PROBABILITY_SUM = 1.02;
+
+let GLOBAL_LOG_ENABLED = false;
+const log = (...args: any[]) => {
+    if (GLOBAL_LOG_ENABLED) {
+        console.log(...args);
+    }
+};
+export const setLogEnabled = (enabled: boolean) => (GLOBAL_LOG_ENABLED = enabled);
+
+/**
+ * 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
+    );
+}