poker-extval 3.1.0 → 3.2.0

package/evaluator.js

@@ -39,10 +39,11 @@ class HandEvaluator {
    * // Non-strict mode - all applicable hands marked
    * const nonStrictEvaluator = new HandEvaluator(['As', 'Ah', 'Kd', 'Kc', 'Qs'], false);
    */
-  constructor(cards, strict = true) {
+  constructor(cards, strict = true, originalCards = null) {
     this.#validateCards(cards);
     this.cards = cards;
     this.strict = strict;
+    this.originalCards = originalCards || (cards.length > 5 ? cards : null);
     this.evaluation = this.#evaluateAllCombinations();
   }
 
@@ -198,6 +199,8 @@ class HandEvaluator {
     this.#isOpenEndedStraightDraw();
     this.#isInsideStraightDraw();
     this.#isStraightDraw();
+    this.#isComboDraw();
+    this.#isUnderPair();
     this.#isHighCard();
     
     // Add keyCards and kickerCards before restoring original evaluation
@@ -275,6 +278,121 @@ class HandEvaluator {
     }
   }
 
+  /**
+   * Gets the hand strength value for an evaluation.
+   * 
+   * @private
+   * @param {Object} evaluation - The evaluation object
+   * @returns {number} Hand strength (10 = Royal Flush, 1 = High Card, 0 = no made hand)
+   */
+  #getHandStrength(evaluation) {
+    const handStrength = {
+      isRoyalFlush: 10, isStraightFlush: 9, isFourOfAKind: 8,
+      isFullHouse: 7, isFlush: 6, isStraight: 5, isThreeOfAKind: 4,
+      isTwoPair: 3, isPair: 2, isHighCard: 1
+    };
+    for (const [hand, strength] of Object.entries(handStrength)) {
+      if (evaluation[hand]) return strength;
+    }
+    return 0;
+  }
+
+  /**
+   * Gets sorted key card ranks for an evaluation.
+   * 
+   * @private
+   * @param {Object} evaluation - The evaluation object
+   * @returns {number[]} Array of rank values sorted descending
+   */
+  #getKeyCardRanks(evaluation) {
+    const handStrength = {
+      isRoyalFlush: 10, isStraightFlush: 9, isFourOfAKind: 8,
+      isFullHouse: 7, isFlush: 6, isStraight: 5, isThreeOfAKind: 4,
+      isTwoPair: 3, isPair: 2, isHighCard: 1
+    };
+    for (const [hand] of Object.entries(handStrength)) {
+      if (evaluation[hand]) {
+        const keyCards = evaluation.keyCards[hand] || [];
+        return keyCards.map(c => this.#getRankValue(c)).sort((a, b) => b - a);
+      }
+    }
+    return [];
+  }
+
+  /**
+   * Gets sorted kicker ranks for an evaluation.
+   * 
+   * @private
+   * @param {Object} evaluation - The evaluation object
+   * @returns {number[]} Array of rank values sorted descending
+   */
+  #getKickerRanks(evaluation) {
+    const handStrength = {
+      isRoyalFlush: 10, isStraightFlush: 9, isFourOfAKind: 8,
+      isFullHouse: 7, isFlush: 6, isStraight: 5, isThreeOfAKind: 4,
+      isTwoPair: 3, isPair: 2, isHighCard: 1
+    };
+    for (const [hand] of Object.entries(handStrength)) {
+      if (evaluation[hand]) {
+        const kickers = evaluation.kickerCards[hand] || [];
+        return kickers.map(c => this.#getRankValue(c)).sort((a, b) => b - a);
+      }
+    }
+    return [];
+  }
+
+  /**
+   * Compares two evaluations to determine which is better.
+   * 
+   * @private
+   * @param {Object} eval1 - First evaluation object
+   * @param {Object} eval2 - Second evaluation object
+   * @returns {number} Positive if eval2 is better, negative if eval1 is better, 0 if equal
+   */
+  #compareEvaluations(eval1, eval2) {
+    const strength1 = this.#getHandStrength(eval1);
+    const strength2 = this.#getHandStrength(eval2);
+    if (strength1 !== strength2) return strength2 - strength1;
+    
+    const keyRanks1 = this.#getKeyCardRanks(eval1);
+    const keyRanks2 = this.#getKeyCardRanks(eval2);
+    for (let i = 0; i < Math.max(keyRanks1.length, keyRanks2.length); i++) {
+      const rank1 = keyRanks1[i] || 0;
+      const rank2 = keyRanks2[i] || 0;
+      if (rank1 !== rank2) return rank2 - rank1;
+    }
+    
+    const kickerRanks1 = this.#getKickerRanks(eval1);
+    const kickerRanks2 = this.#getKickerRanks(eval2);
+    for (let i = 0; i < Math.max(kickerRanks1.length, kickerRanks2.length); i++) {
+      const rank1 = kickerRanks1[i] || 0;
+      const rank2 = kickerRanks2[i] || 0;
+      if (rank1 !== rank2) return rank2 - rank1;
+    }
+    return 0;
+  }
+
+  /**
+   * Finds the best combination from a result object.
+   * 
+   * @private
+   * @param {Object} result - Object mapping hand keys to evaluation objects
+   * @returns {Object} Object with only the best combination
+   */
+  #findBestCombination(result) {
+    let bestKey = null;
+    let bestEval = null;
+    for (const [key, evaluation] of Object.entries(result)) {
+      const strength = this.#getHandStrength(evaluation);
+      const bestStrength = bestEval ? this.#getHandStrength(bestEval) : 0;
+      if (!bestEval || strength > bestStrength || (strength === bestStrength && this.#compareEvaluations(evaluation, bestEval) > 0)) {
+        bestKey = key;
+        bestEval = evaluation;
+      }
+    }
+    return bestKey ? { [bestKey]: bestEval } : result;
+  }
+
   /**
    * Evaluates all possible 5-card combinations from the input cards.
    * For exactly 5 cards, evaluates directly. For more cards, generates all combinations
@@ -290,26 +408,22 @@ class HandEvaluator {
    * // With 7 cards: returns object with 21 key-value pairs (C(7,5) = 21)
    */
   #evaluateAllCombinations() {
-    // If exactly 5 cards, evaluate directly and wrap in the new format
     if (this.cards.length === 5) {
       const key = this.#formatHandKey(this.cards);
       const evaluation = this.#evaluateSingleHand();
       return { [key]: evaluation };
     }
     
-    // For more than 5 cards, generate all combinations
     const combinations = this.#generateCombinations(this.cards, 5);
     const result = {};
     for (const combination of combinations) {
       const key = this.#formatHandKey(combination);
-      // Create a temporary evaluator with the 5-card combination
-      // This will evaluate directly since it's exactly 5 cards
-      const tempEvaluator = new HandEvaluator(combination);
-      // Extract the evaluation object from the single key-value pair
+      const tempEvaluator = new HandEvaluator(combination, this.strict, this.originalCards);
       const evaluationKey = Object.keys(tempEvaluator.evaluation)[0];
       result[key] = tempEvaluator.evaluation[evaluationKey];
     }
-    return result;
+    
+    return this.strict ? this.#findBestCombination(result) : result;
   }
 
   /**
@@ -1319,6 +1433,33 @@ class HandEvaluator {
     return this.#getStraightDrawCards();
   }
 
+  /**
+   * Gets key cards for combo draw (flush draw + straight draw).
+   * Returns the union of flush draw and straight draw cards.
+   * 
+   * @private
+   * @returns {string[]} Array of cards forming the combo draw, empty array otherwise
+   */
+  #getKeyCardsForComboDraw() {
+    if (!this.evaluation.isComboDraw) return [];
+    const flushCards = this.#getKeyCardsForFlushDraw();
+    const straightCards = this.#getKeyCardsForStraightDraw();
+    const allCards = [...flushCards, ...straightCards];
+    const uniqueCards = [...new Set(allCards)];
+    return uniqueCards.sort((a, b) => this.#getRankValue(b) - this.#getRankValue(a));
+  }
+
+  /**
+   * Gets key cards for under pair (the two cards forming the pair).
+   * 
+   * @private
+   * @returns {string[]} Array of 2 cards if under pair, empty array otherwise
+   */
+  #getKeyCardsForUnderPair() {
+    if (!this.evaluation.isUnderPair) return [];
+    return this.#getKeyCardsForPair();
+  }
+
   /**
    * Gets key cards for wheel straight (5 cards forming wheel).
    * 
@@ -1396,6 +1537,8 @@ class HandEvaluator {
       isStraightWheel: this.#getKeyCardsForStraightWheel(),
       isOpenEndedStraightDrawWheel: this.#getKeyCardsForOpenEndedStraightDrawWheel(),
       isInsideStraightDrawWheel: this.#getKeyCardsForInsideStraightDrawWheel(),
+      isComboDraw: this.#getKeyCardsForComboDraw(),
+      isUnderPair: this.#getKeyCardsForUnderPair(),
       isHighCard: this.#getKeyCardsForHighCard()
     };
   }
@@ -1468,6 +1611,62 @@ class HandEvaluator {
 
   // ==================== HIGH CARD ====================
   
+  /**
+   * Determines if the hand has both a flush draw and a straight draw simultaneously.
+   * Requires both isFlushDraw (not backdoor) and isStraightDraw to be true.
+   * 
+   * @returns {boolean} True if the hand is a combo draw, false otherwise
+   * @example
+   * const evaluator = new HandEvaluator(['9s', '8s', '7s', '6s', 'Kh']);
+   * evaluator.isComboDraw(); // Returns true (flush draw + straight draw)
+   */
+  #isComboDraw() {
+    if (this.evaluation.isComboDraw !== undefined) return this.evaluation.isComboDraw;
+    if (this.evaluation.isFlushDraw === undefined) this.#isFlushDraw();
+    if (this.evaluation.isStraightDraw === undefined) this.#isStraightDraw();
+    if (this.evaluation.isBackdoorFlushDraw === undefined) this.#isBackdoorFlushDraw();
+    return this.evaluation.isComboDraw = this.evaluation.isFlushDraw && 
+           this.evaluation.isStraightDraw && 
+           !this.evaluation.isBackdoorFlushDraw;
+  }
+
+  /**
+   * Determines if the hand contains an under pair (pocket pair smaller than all board cards).
+   * Only applicable when evaluating 6+ cards where the pair rank is smaller than all other cards.
+   * 
+   * @returns {boolean} True if the hand is an under pair, false otherwise
+   * @example
+   * // Board: K♠ Q♠ J♠ 8♠, Hand: 77
+   * const evaluator = new HandEvaluator(['Ks', 'Qh', 'Jd', '8c', '7c', '7h']);
+   * evaluator.isUnderPair(); // Returns true (pair of 7s is smaller than all board cards)
+   */
+  #isUnderPair() {
+    if (this.evaluation.isUnderPair !== undefined) return this.evaluation.isUnderPair;
+    if (this.evaluation.isPair === undefined) this.#isPair();
+    if (!this.evaluation.isPair || !this.originalCards || this.originalCards.length < 6) {
+      return this.evaluation.isUnderPair = false;
+    }
+    const pairRank = this.#getPairRank();
+    if (!pairRank) return this.evaluation.isUnderPair = false;
+    const otherCards = this.originalCards.filter(c => c.slice(0, -1) !== pairRank);
+    const minOtherRank = Math.min(...otherCards.map(c => this.#getRankValue(c)));
+    return this.evaluation.isUnderPair = this.#getRankValue(pairRank + 's') < minOtherRank;
+  }
+
+  /**
+   * Gets the rank of the pair in the current hand.
+   * 
+   * @private
+   * @returns {string|null} The rank of the pair, or null if no pair exists
+   */
+  #getPairRank() {
+    const rankCounts = this.#getRankCounts();
+    for (const [rank, count] of Object.entries(rankCounts)) {
+      if (count === 2) return rank;
+    }
+    return null;
+  }
+  
   /**
    * Determines if the hand is high card only (no pairs, two pair, three of a kind, full house,
    * four of a kind, flush, or straight).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "poker-extval",
-  "version": "3.1.0",
+  "version": "3.2.0",
   "description": "Poker hand evaluator with comprehensive test suite",
   "main": "evaluator.js",
   "files": [