@kekkle/shared 1.2.0 → 1.3.0

package/dist/cjs/fixtures/character-state.fixtures.d.ts

@@ -0,0 +1,2 @@
+import type { CharacterState } from "../types/wordle-game-state";
+export declare function createCharacterState(character: string, isCorrect: boolean, isLocked?: boolean): CharacterState;

package/dist/cjs/fixtures/character-state.fixtures.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCharacterState = createCharacterState;
+function createCharacterState(character, isCorrect, isLocked = false) {
+    return { character, isCorrect, isLocked };
+}

package/dist/cjs/fixtures/wordle-row.fixtures.d.ts

@@ -0,0 +1,5 @@
+import type { WordleRow } from "../types/wordle-game-state";
+export declare function createWordleRow(inputWord: string, correctWord: string): WordleRow;
+export declare function createAllCorrectWordleRow(word: string): WordleRow;
+export declare function createAllIncorrectWordleRow(word: string): WordleRow;
+export declare function createPartialWordleRow(word: string, correctIndices: number[]): WordleRow;

package/dist/cjs/fixtures/wordle-row.fixtures.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWordleRow = createWordleRow;
+exports.createAllCorrectWordleRow = createAllCorrectWordleRow;
+exports.createAllIncorrectWordleRow = createAllIncorrectWordleRow;
+exports.createPartialWordleRow = createPartialWordleRow;
+const character_state_fixtures_1 = require("./character-state.fixtures");
+function createWordleRow(inputWord, correctWord) {
+    if (inputWord.length !== correctWord.length) {
+        throw new Error("Input word and correct word must be the same length");
+    }
+    return inputWord
+        .split("")
+        .map((char, index) => (0, character_state_fixtures_1.createCharacterState)(char, char === correctWord[index]));
+}
+function createAllCorrectWordleRow(word) {
+    return word.split("").map((char) => (0, character_state_fixtures_1.createCharacterState)(char, true, false));
+}
+function createAllIncorrectWordleRow(word) {
+    return word.split("").map((char) => (0, character_state_fixtures_1.createCharacterState)(char, false, false));
+}
+function createPartialWordleRow(word, correctIndices) {
+    return word
+        .split("")
+        .map((char, index) => (0, character_state_fixtures_1.createCharacterState)(char, correctIndices.includes(index), false));
+}

package/dist/cjs/helpers/worlde/all-correct-in-row.d.ts

@@ -0,0 +1,5 @@
+import type { WordleRow } from "../../types/wordle-game-state";
+/**
+ * Method to determine if all characters are correct for a given WordleRow
+ */
+export declare function allCorrectInRow(row: WordleRow): boolean;

package/dist/cjs/helpers/worlde/all-correct-in-row.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.allCorrectInRow = allCorrectInRow;
+/**
+ * Method to determine if all characters are correct for a given WordleRow
+ */
+function allCorrectInRow(row) {
+    return row.every((cell) => cell.isCorrect);
+}

package/dist/cjs/helpers/worlde/calculate-wordle-score.d.ts

@@ -0,0 +1,12 @@
+import type { WordleGameState } from "../../types/wordle-game-state";
+/**
+ * Calculates the score for a Wordle game based on the current game state.
+ *
+ * Scoring rules:
+ * - If the game is won (any row has all correct letters):
+ *   - Base score equals the length of a row (typically 5)
+ *   - Bonus points are added based on how quickly the word was guessed (6 minus attempts used)
+ * - If the game is not won yet:
+ *   - Score equals the number of correct cells in the latest row
+ */
+export declare function calculateWordleScore(gameState: WordleGameState): number;

package/dist/cjs/helpers/worlde/calculate-wordle-score.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateWordleScore = calculateWordleScore;
+const all_correct_in_row_1 = require("./all-correct-in-row");
+/**
+ * Calculates the score for a Wordle game based on the current game state.
+ *
+ * Scoring rules:
+ * - If the game is won (any row has all correct letters):
+ *   - Base score equals the length of a row (typically 5)
+ *   - Bonus points are added based on how quickly the word was guessed (6 minus attempts used)
+ * - If the game is not won yet:
+ *   - Score equals the number of correct cells in the latest row
+ */
+function calculateWordleScore(gameState) {
+    // Handle empty game state
+    if (gameState.length === 0) {
+        return 0;
+    }
+    let score = 0;
+    let hasWon = false;
+    // Iterate over each row in the game state to check for a win condition
+    for (const row of gameState) {
+        // If all cells in a row are correct, the game is won
+        if ((0, all_correct_in_row_1.allCorrectInRow)(row)) {
+            hasWon = true;
+            break;
+        }
+    }
+    // Case 1: Game in progress (not yet won)
+    if (!hasWon) {
+        // Score is based on correct cells in the latest attempt
+        score = gameState[gameState.length - 1].filter((cell) => cell.isCorrect).length;
+        return score;
+    }
+    // Case 2: Game is won
+    // Base score is the row length (number of letters in the word)
+    score = gameState[0].length;
+    // Calculate which attempt was successful (1-based index)
+    const numberOfTriesNeeded = gameState.findIndex(all_correct_in_row_1.allCorrectInRow) + 1;
+    // Award bonus points based on how quickly the word was guessed
+    // Maximum bonus (5) for first try, decreasing by 1 for each additional attempt
+    const bonusPoints = 6 - numberOfTriesNeeded;
+    return score + bonusPoints;
+}

package/dist/esm/fixtures/character-state.fixtures.d.ts

@@ -0,0 +1,2 @@
+import type { CharacterState } from "../types/wordle-game-state";
+export declare function createCharacterState(character: string, isCorrect: boolean, isLocked?: boolean): CharacterState;

package/dist/esm/fixtures/character-state.fixtures.js

@@ -0,0 +1,3 @@
+export function createCharacterState(character, isCorrect, isLocked = false) {
+    return { character, isCorrect, isLocked };
+}

package/dist/esm/fixtures/wordle-row.fixtures.d.ts

@@ -0,0 +1,5 @@
+import type { WordleRow } from "../types/wordle-game-state";
+export declare function createWordleRow(inputWord: string, correctWord: string): WordleRow;
+export declare function createAllCorrectWordleRow(word: string): WordleRow;
+export declare function createAllIncorrectWordleRow(word: string): WordleRow;
+export declare function createPartialWordleRow(word: string, correctIndices: number[]): WordleRow;

package/dist/esm/fixtures/wordle-row.fixtures.js

@@ -0,0 +1,20 @@
+import { createCharacterState } from "./character-state.fixtures";
+export function createWordleRow(inputWord, correctWord) {
+    if (inputWord.length !== correctWord.length) {
+        throw new Error("Input word and correct word must be the same length");
+    }
+    return inputWord
+        .split("")
+        .map((char, index) => createCharacterState(char, char === correctWord[index]));
+}
+export function createAllCorrectWordleRow(word) {
+    return word.split("").map((char) => createCharacterState(char, true, false));
+}
+export function createAllIncorrectWordleRow(word) {
+    return word.split("").map((char) => createCharacterState(char, false, false));
+}
+export function createPartialWordleRow(word, correctIndices) {
+    return word
+        .split("")
+        .map((char, index) => createCharacterState(char, correctIndices.includes(index), false));
+}

package/dist/esm/helpers/worlde/all-correct-in-row.d.ts

@@ -0,0 +1,5 @@
+import type { WordleRow } from "../../types/wordle-game-state";
+/**
+ * Method to determine if all characters are correct for a given WordleRow
+ */
+export declare function allCorrectInRow(row: WordleRow): boolean;

package/dist/esm/helpers/worlde/all-correct-in-row.js

@@ -0,0 +1,6 @@
+/**
+ * Method to determine if all characters are correct for a given WordleRow
+ */
+export function allCorrectInRow(row) {
+    return row.every((cell) => cell.isCorrect);
+}

package/dist/esm/helpers/worlde/calculate-wordle-score.d.ts

@@ -0,0 +1,12 @@
+import type { WordleGameState } from "../../types/wordle-game-state";
+/**
+ * Calculates the score for a Wordle game based on the current game state.
+ *
+ * Scoring rules:
+ * - If the game is won (any row has all correct letters):
+ *   - Base score equals the length of a row (typically 5)
+ *   - Bonus points are added based on how quickly the word was guessed (6 minus attempts used)
+ * - If the game is not won yet:
+ *   - Score equals the number of correct cells in the latest row
+ */
+export declare function calculateWordleScore(gameState: WordleGameState): number;

package/dist/esm/helpers/worlde/calculate-wordle-score.js

@@ -0,0 +1,42 @@
+import { allCorrectInRow } from "./all-correct-in-row";
+/**
+ * Calculates the score for a Wordle game based on the current game state.
+ *
+ * Scoring rules:
+ * - If the game is won (any row has all correct letters):
+ *   - Base score equals the length of a row (typically 5)
+ *   - Bonus points are added based on how quickly the word was guessed (6 minus attempts used)
+ * - If the game is not won yet:
+ *   - Score equals the number of correct cells in the latest row
+ */
+export function calculateWordleScore(gameState) {
+    // Handle empty game state
+    if (gameState.length === 0) {
+        return 0;
+    }
+    let score = 0;
+    let hasWon = false;
+    // Iterate over each row in the game state to check for a win condition
+    for (const row of gameState) {
+        // If all cells in a row are correct, the game is won
+        if (allCorrectInRow(row)) {
+            hasWon = true;
+            break;
+        }
+    }
+    // Case 1: Game in progress (not yet won)
+    if (!hasWon) {
+        // Score is based on correct cells in the latest attempt
+        score = gameState[gameState.length - 1].filter((cell) => cell.isCorrect).length;
+        return score;
+    }
+    // Case 2: Game is won
+    // Base score is the row length (number of letters in the word)
+    score = gameState[0].length;
+    // Calculate which attempt was successful (1-based index)
+    const numberOfTriesNeeded = gameState.findIndex(allCorrectInRow) + 1;
+    // Award bonus points based on how quickly the word was guessed
+    // Maximum bonus (5) for first try, decreasing by 1 for each additional attempt
+    const bonusPoints = 6 - numberOfTriesNeeded;
+    return score + bonusPoints;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kekkle/shared",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "description": "Shared logic and types for Kekkle frontend and functions",
   "type": "module",
   "exports": {
@@ -23,6 +23,11 @@
       "types": "./src/helpers/*.ts",
       "import": "./dist/esm/helpers/*.js",
       "require": "./dist/cjs/helpers/*.js"
+    },
+    "./fixtures/*": {
+      "types": "./src/fixtures/*.ts",
+      "import": "./dist/esm/fixtures/*.js",
+      "require": "./dist/cjs/fixtures/*.js"
     }
   },
   "files": [
@@ -30,7 +35,10 @@
     "dist/**/*"
   ],
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1",
+    "test": "vitest",
+    "test:run": "vitest run",
+    "test:ui": "vitest --ui",
+    "test:coverage": "vitest run --coverage",
     "build": "npm run build:esm && npm run build:cjs",
     "build:esm": "tsc -p tsconfig.esm.json",
     "build:cjs": "tsc -p tsconfig.cjs.json",
@@ -58,6 +66,8 @@
     "@semantic-release/github": "^11.0.3",
     "@semantic-release/release-notes-generator": "^14.0.3",
     "@types/eslint__js": "^8.42.3",
+    "@vitest/coverage-v8": "^3.2.4",
+    "@vitest/ui": "^3.2.4",
     "conventional-changelog-conventionalcommits": "^9.0.0",
     "eslint": "^9.12.0",
     "eslint-config-prettier": "^10.1.5",
@@ -65,7 +75,8 @@
     "prettier": "^3.6.0",
     "semantic-release": "^24.2.5",
     "typescript": "^5.6.3",
-    "typescript-eslint": "^8.8.1"
+    "typescript-eslint": "^8.8.1",
+    "vitest": "^3.2.4"
   },
   "peerDependencies": {
     "firebase-admin": "11.11.1",

package/src/fixtures/character-state.fixtures.ts

@@ -0,0 +1,9 @@
+import type { CharacterState } from "../types/wordle-game-state";
+
+export function createCharacterState(
+  character: string,
+  isCorrect: boolean,
+  isLocked: boolean = false,
+): CharacterState {
+  return { character, isCorrect, isLocked };
+}

package/src/fixtures/wordle-row.fixtures.ts

@@ -0,0 +1,36 @@
+import type { WordleRow } from "../types/wordle-game-state";
+import { createCharacterState } from "./character-state.fixtures";
+
+export function createWordleRow(
+  inputWord: string,
+  correctWord: string,
+): WordleRow {
+  if (inputWord.length !== correctWord.length) {
+    throw new Error("Input word and correct word must be the same length");
+  }
+
+  return inputWord
+    .split("")
+    .map((char, index) =>
+      createCharacterState(char, char === correctWord[index]),
+    );
+}
+
+export function createAllCorrectWordleRow(word: string): WordleRow {
+  return word.split("").map((char) => createCharacterState(char, true, false));
+}
+
+export function createAllIncorrectWordleRow(word: string): WordleRow {
+  return word.split("").map((char) => createCharacterState(char, false, false));
+}
+
+export function createPartialWordleRow(
+  word: string,
+  correctIndices: number[],
+): WordleRow {
+  return word
+    .split("")
+    .map((char, index) =>
+      createCharacterState(char, correctIndices.includes(index), false),
+    );
+}

package/src/helpers/permissions/is-valid-permission.vi.spec.ts

@@ -0,0 +1,109 @@
+import { describe, it, expect } from "vitest";
+import { isValidPermission } from "./is-valid-permission";
+import { GroupPermission } from "../../enums/group-permission";
+
+describe("isValidPermission", () => {
+  describe("Valid permissions", () => {
+    it("should return true for ADMIN permission", () => {
+      expect(isValidPermission(GroupPermission.ADMIN)).toBe(true);
+    });
+
+    it("should return true for ORGANISER permission", () => {
+      expect(isValidPermission(GroupPermission.ORGANISER)).toBe(true);
+    });
+
+    it("should return true for MEMBER permission", () => {
+      expect(isValidPermission(GroupPermission.MEMBER)).toBe(true);
+    });
+
+    it("should return true for admin string value", () => {
+      expect(isValidPermission("admin")).toBe(true);
+    });
+
+    it("should return true for organiser string value", () => {
+      expect(isValidPermission("organiser")).toBe(true);
+    });
+
+    it("should return true for member string value", () => {
+      expect(isValidPermission("member")).toBe(true);
+    });
+  });
+
+  describe("Invalid permissions", () => {
+    it("should return false for invalid permission string", () => {
+      expect(isValidPermission("invalid")).toBe(false);
+    });
+
+    it("should return false for empty string", () => {
+      expect(isValidPermission("")).toBe(false);
+    });
+
+    it("should return false for uppercase permission", () => {
+      expect(isValidPermission("ADMIN")).toBe(false);
+    });
+
+    it("should return false for mixed case permission", () => {
+      expect(isValidPermission("Admin")).toBe(false);
+    });
+
+    it("should return false for permission with extra spaces", () => {
+      expect(isValidPermission(" admin ")).toBe(false);
+    });
+
+    it("should return false for permission with different spelling", () => {
+      expect(isValidPermission("administrator")).toBe(false);
+    });
+
+    it("should return false for partial permission match", () => {
+      expect(isValidPermission("admi")).toBe(false);
+    });
+
+    it("should return false for null-like string", () => {
+      expect(isValidPermission("null")).toBe(false);
+    });
+
+    it("should return false for undefined-like string", () => {
+      expect(isValidPermission("undefined")).toBe(false);
+    });
+  });
+
+  describe("Edge cases", () => {
+    it("should return false for numeric string", () => {
+      expect(isValidPermission("123")).toBe(false);
+    });
+
+    it("should return false for special characters", () => {
+      expect(isValidPermission("@admin")).toBe(false);
+    });
+
+    it("should return false for permission with hyphen", () => {
+      expect(isValidPermission("admin-user")).toBe(false);
+    });
+
+    it("should return false for permission with underscore", () => {
+      expect(isValidPermission("admin_user")).toBe(false);
+    });
+
+    it("should handle all enum values dynamically", () => {
+      // This test ensures all current enum values are valid
+      Object.values(GroupPermission).forEach((permission) => {
+        expect(isValidPermission(permission)).toBe(true);
+      });
+    });
+
+    it("should return false for non-enum string values", () => {
+      const invalidPermissions = [
+        "guest",
+        "viewer",
+        "editor",
+        "owner",
+        "moderator",
+        "user",
+      ];
+
+      invalidPermissions.forEach((permission) => {
+        expect(isValidPermission(permission)).toBe(false);
+      });
+    });
+  });
+});

package/src/helpers/worlde/all-correct-in-row.ts

@@ -0,0 +1,8 @@
+import type { CharacterState, WordleRow } from "../../types/wordle-game-state";
+
+/**
+ * Method to determine if all characters are correct for a given WordleRow
+ */
+export function allCorrectInRow(row: WordleRow): boolean {
+  return row.every((cell: CharacterState) => cell.isCorrect);
+}

package/src/helpers/worlde/all-correct-in-row.vi.spec.ts

@@ -0,0 +1,96 @@
+import { describe, it, expect } from "vitest";
+import { allCorrectInRow } from "./all-correct-in-row";
+import {
+  createWordleRow,
+  createAllCorrectWordleRow,
+  createAllIncorrectWordleRow,
+  createPartialWordleRow,
+} from "../../fixtures/wordle-row.fixtures";
+
+describe("allCorrectInRow", () => {
+  describe("All correct scenarios", () => {
+    it("should return true when all letters in a 5-letter row are correct", () => {
+      const row = createAllCorrectWordleRow("HOUSE");
+
+      expect(allCorrectInRow(row)).toBe(true);
+    });
+
+    it("should return true when all letters in a 4-letter row are correct", () => {
+      const row = createAllCorrectWordleRow("WORD");
+
+      expect(allCorrectInRow(row)).toBe(true);
+    });
+
+    it("should return true when all letters in a 6-letter row are correct", () => {
+      const row = createAllCorrectWordleRow("PUZZLE");
+
+      expect(allCorrectInRow(row)).toBe(true);
+    });
+
+    it("should return true for a single correct letter", () => {
+      const row = createAllCorrectWordleRow("A");
+
+      expect(allCorrectInRow(row)).toBe(true);
+    });
+  });
+
+  describe("All incorrect scenarios", () => {
+    it("should return false when all letters are incorrect", () => {
+      const row = createAllIncorrectWordleRow("WRONG");
+
+      expect(allCorrectInRow(row)).toBe(false);
+    });
+
+    it("should return false for a single incorrect letter", () => {
+      const row = createAllIncorrectWordleRow("X");
+
+      expect(allCorrectInRow(row)).toBe(false);
+    });
+  });
+
+  describe("Partial correct scenarios", () => {
+    it("should return false when only first letter is correct", () => {
+      const row = createWordleRow("HOUSE", "HXXXX");
+
+      expect(allCorrectInRow(row)).toBe(false);
+    });
+
+    it("should return false when only last letter is correct", () => {
+      const row = createWordleRow("HOUSE", "XXXXE");
+
+      expect(allCorrectInRow(row)).toBe(false);
+    });
+
+    it("should return false when middle letters are correct", () => {
+      const row = createWordleRow("HOUSE", "XOUSX");
+
+      expect(allCorrectInRow(row)).toBe(false);
+    });
+
+    it("should return false when most letters are correct but one is wrong", () => {
+      const row = createWordleRow("HOUSE", "HOUSX");
+
+      expect(allCorrectInRow(row)).toBe(false);
+    });
+
+    it("should return false using partial row fixture with specific indices", () => {
+      const row = createPartialWordleRow("FLAME", [0, 2, 4]); // F, A, E correct
+
+      expect(allCorrectInRow(row)).toBe(false);
+    });
+  });
+
+  describe("Edge cases", () => {
+    it("should return true for empty row", () => {
+      const row = createWordleRow("", "");
+
+      expect(allCorrectInRow(row)).toBe(true);
+    });
+
+    it("should handle mixed correct and locked states", () => {
+      const row = createWordleRow("TEST", "TEXX");
+
+      expect(allCorrectInRow(row)).toBe(false);
+    });
+  });
+});

package/src/helpers/worlde/calculate-wordle-score.ts

@@ -0,0 +1,53 @@
+import type { WordleGameState } from "../../types/wordle-game-state";
+import { allCorrectInRow } from "./all-correct-in-row";
+
+/**
+ * Calculates the score for a Wordle game based on the current game state.
+ *
+ * Scoring rules:
+ * - If the game is won (any row has all correct letters):
+ *   - Base score equals the length of a row (typically 5)
+ *   - Bonus points are added based on how quickly the word was guessed (6 minus attempts used)
+ * - If the game is not won yet:
+ *   - Score equals the number of correct cells in the latest row
+ */
+export function calculateWordleScore(gameState: WordleGameState): number {
+  // Handle empty game state
+  if (gameState.length === 0) {
+    return 0;
+  }
+
+  let score = 0;
+  let hasWon = false;
+
+  // Iterate over each row in the game state to check for a win condition
+  for (const row of gameState) {
+    // If all cells in a row are correct, the game is won
+    if (allCorrectInRow(row)) {
+      hasWon = true;
+      break;
+    }
+  }
+
+  // Case 1: Game in progress (not yet won)
+  if (!hasWon) {
+    // Score is based on correct cells in the latest attempt
+    score = gameState[gameState.length - 1].filter(
+      (cell) => cell.isCorrect,
+    ).length;
+    return score;
+  }
+
+  // Case 2: Game is won
+  // Base score is the row length (number of letters in the word)
+  score = gameState[0].length;
+
+  // Calculate which attempt was successful (1-based index)
+  const numberOfTriesNeeded = gameState.findIndex(allCorrectInRow) + 1;
+
+  // Award bonus points based on how quickly the word was guessed
+  // Maximum bonus (5) for first try, decreasing by 1 for each additional attempt
+  const bonusPoints = 6 - numberOfTriesNeeded;
+
+  return score + bonusPoints;
+}

package/src/helpers/worlde/calculate-wordle-score.vi.spec.ts

@@ -0,0 +1,171 @@
+import { describe, it, expect } from "vitest";
+import { calculateWordleScore } from "./calculate-wordle-score";
+import type { WordleGameState } from "../../types/wordle-game-state";
+import {
+  createWordleRow,
+  createAllCorrectWordleRow,
+  createAllIncorrectWordleRow,
+} from "../../fixtures/wordle-row.fixtures";
+
+describe("calculateWordleScore", () => {
+  describe("Game in progress (not won)", () => {
+    it("should return 0 when no letters are correct in the latest row", () => {
+      const gameState: WordleGameState = [createAllIncorrectWordleRow("WRONG")];
+
+      expect(calculateWordleScore(gameState)).toBe(0);
+    });
+
+    it("should return 1 when one letter is correct in the latest row", () => {
+      const gameState: WordleGameState = [
+        createAllIncorrectWordleRow("WRONG"),
+        createWordleRow("HOUSE", "HXXXX"),
+      ];
+
+      expect(calculateWordleScore(gameState)).toBe(1);
+    });
+
+    it("should return 3 when three letters are correct in the latest row", () => {
+      const gameState: WordleGameState = [
+        createAllIncorrectWordleRow("WRONG"),
+        createWordleRow("HOUSE", "HXUXE"),
+      ];
+
+      expect(calculateWordleScore(gameState)).toBe(3);
+    });
+
+    it("should only count correct letters from the latest row when game not won", () => {
+      const gameState: WordleGameState = [
+        createAllIncorrectWordleRow("WRONG"), // No correct in first row
+        createWordleRow("HOUSE", "HXXXX"), // Only one correct in latest row
+      ];
+
+      expect(calculateWordleScore(gameState)).toBe(1);
+    });
+  });
+
+  describe("Game won", () => {
+    it("should return 10 when won on first try (5 + 5 bonus)", () => {
+      const gameState: WordleGameState = [createAllCorrectWordleRow("HOUSE")];
+
+      expect(calculateWordleScore(gameState)).toBe(10);
+    });
+
+    it("should return 9 when won on second try (5 + 4 bonus)", () => {
+      const gameState: WordleGameState = [
+        createAllIncorrectWordleRow("WRONG"),
+        createAllCorrectWordleRow("HOUSE"),
+      ];
+
+      expect(calculateWordleScore(gameState)).toBe(9);
+    });
+
+    it("should return 8 when won on third try (5 + 3 bonus)", () => {
+      const gameState: WordleGameState = [
+        createAllIncorrectWordleRow("WRONG"),
+        createAllIncorrectWordleRow("TESTS"),
+        createAllCorrectWordleRow("HOUSE"),
+      ];
+
+      expect(calculateWordleScore(gameState)).toBe(8);
+    });
+
+    it("should return 7 when won on fourth try (5 + 2 bonus)", () => {
+      const gameState: WordleGameState = [
+        createAllIncorrectWordleRow("WRONG"),
+        createAllIncorrectWordleRow("TESTS"),
+        createAllIncorrectWordleRow("FLAME"),
+        createAllCorrectWordleRow("HOUSE"),
+      ];
+
+      expect(calculateWordleScore(gameState)).toBe(7);
+    });
+
+    it("should return 6 when won on fifth try (5 + 1 bonus)", () => {
+      const gameState: WordleGameState = [
+        createAllIncorrectWordleRow("WRONG"),
+        createAllIncorrectWordleRow("TESTS"),
+        createAllIncorrectWordleRow("FLAME"),
+        createAllIncorrectWordleRow("STEAM"),
+        createAllCorrectWordleRow("HOUSE"),
+      ];
+
+      expect(calculateWordleScore(gameState)).toBe(6);
+    });
+
+    it("should return 5 when won on sixth try (5 + 0 bonus)", () => {
+      const gameState: WordleGameState = [
+        createAllIncorrectWordleRow("WRONG"),
+        createAllIncorrectWordleRow("TESTS"),
+        createAllIncorrectWordleRow("FLAME"),
+        createAllIncorrectWordleRow("STEAM"),
+        createAllIncorrectWordleRow("GRAND"),
+        createAllCorrectWordleRow("HOUSE"),
+      ];
+
+      expect(calculateWordleScore(gameState)).toBe(5);
+    });
+
+    it("should find winning row even when not the last row", () => {
+      const gameState: WordleGameState = [
+        createAllIncorrectWordleRow("WRONG"),
+        createAllCorrectWordleRow("HOUSE"), // Winning row
+        createAllIncorrectWordleRow("TESTS"), // Additional row after win
+      ];
+
+      expect(calculateWordleScore(gameState)).toBe(9); // Won on second try
+    });
+  });
+
+  describe("Edge cases", () => {
+    it("should handle single row game state", () => {
+      const gameState: WordleGameState = [createWordleRow("HOUSE", "HXUXX")];
+
+      expect(calculateWordleScore(gameState)).toBe(2);
+    });
+
+    it("should handle empty game state", () => {
+      const gameState: WordleGameState = [];
+
+      expect(calculateWordleScore(gameState)).toBe(0);
+    });
+
+    it("should handle different word lengths", () => {
+      const gameState: WordleGameState = [createAllCorrectWordleRow("HELLO")];
+
+      expect(calculateWordleScore(gameState)).toBe(10); // 5 + 5 bonus
+    });
+
+    it("should handle 4-letter words", () => {
+      const gameState: WordleGameState = [createAllCorrectWordleRow("WORD")];
+
+      expect(calculateWordleScore(gameState)).toBe(9); // 4 + 5 bonus
+    });
+
+    it("should handle 6-letter words", () => {
+      const gameState: WordleGameState = [createAllCorrectWordleRow("PUZZLE")];
+
+      expect(calculateWordleScore(gameState)).toBe(11); // 6 + 5 bonus
+    });
+  });
+
+  describe("Mixed scenarios", () => {
+    it("should handle partial correct letters in non-winning rows", () => {
+      const gameState: WordleGameState = [
+        createWordleRow("HOUSE", "HXUXX"), // 2 correct
+        createWordleRow("TESTS", "XEXEX"), // 2 correct
+        createAllCorrectWordleRow("FLAME"), // All correct - winning row
+      ];
+
+      expect(calculateWordleScore(gameState)).toBe(8); // Won on third try: 5 + 3 bonus
+    });
+
+    it("should prioritize win condition over partial correct letters", () => {
+      const gameState: WordleGameState = [
+        createAllCorrectWordleRow("HOUSE"), // All correct - should win here
+        createWordleRow("TESTS", "TXXXX"), // Partial correct in later row
+      ];
+
+      expect(calculateWordleScore(gameState)).toBe(10); // Won on first try: 5 + 5 bonus
+    });
+  });
+});