From e0a29438bed85c1933f781d0a5240e841d6c5f43 Mon Sep 17 00:00:00 2001
From: Zakaria <zbenmo1@wgu.edu>
Date: Mon, 24 Aug 2026 00:59:48 -0400
Subject: [PATCH] fixing the definition api issue

---
 .DS_Store                | Bin 10244 -> 12292 bytes
 fancy-wordle-modern.html |   2 +-
 index.html               |   2 +-
 script.js                | 147 ++++++++++++++++++++++++++++++++-------
 4 files changed, 124 insertions(+), 27 deletions(-)
diff --git a/.DS_Store b/.DS_Store
index 20d52eb46f588c951df5351ed9666e6833404f35..eed10fab65375460c758763cb88d9f98d9f04f50 100644
GIT binary patch
delta 1728
zcmd^<O=}ZD7{{O8&C5bkcTL)Awb2|R7K&mI3etmGTkxVN3tqf5NtaD+lHD|^($nTp
zJ&086oYaGYhn~aw0g50(KR`qTk5Y_Kd-mcp(`<GoFU<!qFxi*qKhOWS&oeU{cQ+Q(
z03gk+EzJN-;jM~;UiCP>#)oulD}6qtP!Wz<9C)t-IFN-Ljw+a2l@H`nCKRTE5c!yF
zo>`jD73~~8s;#}+oz2#l8#DwL!GdL|H7ZKPi>e`2(!6J*vaDG%M&2$tsKM+n$H@M~
z32$@!R%Eec&v!E2pLX(Jzp+dzx~}mAB|C6DO6L@Kr}scUO>VnksDX(YYfvrnBrvjz
zJY1Bgd3F1#d+!&c5flMOe}zCm>j+*U^-gZoA1dxNK1H!eSuB$Y<sP7sxhuU29_r5<
z?epwmiMsOe1sbGsp(@bnlrHF+P@DK~3ft)@57DpVynVko^L70taB7DdNBrf2wa5zQ
zAh){XJixiXPyE&hIe3VE8kZUg6=3}V4M7|zVq4bXF|6VWwxEE`xd0`|gCnA?k0IKS
z89eOvbKN-j&eoARbXu^uxM@RXi668BUR=K}xgvC#Zh8f7f&m5(hi~8RHW^$e8Zh)m
zMXx#v{H%|R)pF4;Tlj{a66C@0J(5a9O_5{tESs^6g|!B9w4(z!SXAUld)E@GL?)72
z*Jp<>qg@ntex7yJp&O33{rO_$py_X?E>&PZSS4cMZXydwoBTLkpG4m<4*X5U@Na=X
oZX1<-g=m?pCutaqCAY7k_EjZ?%<I_U@rpU66gid{|4$3~4{hL%d;kCd

delta 185
zcmZokXbF&DU|?W$DortDU{C-uIe-{M3-C-V6q~3gIoUvmMH0wo5C>vLpg03V5<?L~
zB0~v7CPV&aL8fo4n-!SWGHzz)VBugC-<+f5z&Ke(<@@GlRTjp{;_A7RL)1kkt1up#
zEWjwTSwY|(<7OivFSf}aBqncWmYT;T$P6+ZXeT$2a0S^5H1j+2WPTmX$@V-F983@=
SX-rPgnYp=Hpc|yUf)M}{946NQ

diff --git a/fancy-wordle-modern.html b/fancy-wordle-modern.html
index f8b253c..fa3b2bb 100644
--- a/fancy-wordle-modern.html
+++ b/fancy-wordle-modern.html
@@ -10,7 +10,7 @@
   <script src="https://cdn.jsdelivr.net/npm/@supabase/supabase-js@2"></script>
   <script src="word-data.js?v=5" defer></script>
   <script src="supabase-config.js?v=1" defer></script>
-  <script src="script.js?v=10" defer></script>
+  <script src="script.js?v=11" defer></script>
 </head>
 <body class="intro-active dark-theme">
   <section class="intro-overlay" id="intro-overlay" aria-label="Animated Wordle intro" role="dialog" aria-modal="true">
diff --git a/index.html b/index.html
index 33e9fc7..0f75fbe 100644
--- a/index.html
+++ b/index.html
@@ -10,7 +10,7 @@
   <script src="https://cdn.jsdelivr.net/npm/@supabase/supabase-js@2"></script>
   <script src="word-data.js?v=5" defer></script>
   <script src="supabase-config.js?v=1" defer></script>
-  <script src="script.js?v=10" defer></script>
+  <script src="script.js?v=11" defer></script>
 </head>
 <body class="intro-active dark-theme">
   <section class="intro-overlay" id="intro-overlay" aria-label="Animated Wordle intro" role="dialog" aria-modal="true">
diff --git a/script.js b/script.js
index 68f934d..7579d2b 100644
--- a/script.js
+++ b/script.js
@@ -27,6 +27,9 @@ const FLIP_ANIMATION_DURATION = 500
 const DANCE_ANIMATION_DURATION = 500
 const STATS_KEY = "fancy-wordle-stats-v2"
 const LOCAL_ROUND_KEY = "fancy-wordle-hourly-round-v1"
+const DEFINITION_CACHE_KEY = "fancy-wordle-definitions-v1"
+const DEFINITION_CACHE_LIMIT = 200
+const DEFINITION_RETRY_DELAY_MS = 1500
 const PLAY_INTERVAL_MS = 60 * 60 * 1000
 const GUESS_TIMEOUT_MS = 10000
 const INTRO_SEEN_KEY = "fancy-wordle-intro-seen-v1"
@@ -1367,33 +1370,127 @@ function playCelebrationSound() {
   })
 }
 
-async function loadWordDefinition(word, isWin = true) {
+function readDefinitionCache() {
   try {
-    const response = await fetch(`https://api.dictionaryapi.dev/api/v2/entries/en/${word}`)
-    if (!response.ok) throw new Error(`API request failed: ${response.status}`)
-
-    const data = await response.json()
-    const firstMeaning = data[0]?.meanings?.[0]
-    const definition = firstMeaning?.definitions?.[0]?.definition
-    const partOfSpeech = firstMeaning?.partOfSpeech
-    const example = firstMeaning?.definitions?.[0]?.example
-
-    if (!definition) throw new Error("No definition found")
-
-    lastDefinition = {
-      title: `${word.toUpperCase()} ${partOfSpeech ? `(${partOfSpeech})` : ""}`,
-      body: definition,
-      example,
-      isWin
-    }
-  } catch (error) {
-    console.info("Definition lookup unavailable:", error)
-    lastDefinition = {
-      title: word.toUpperCase(),
-      body: "Definition not available at the moment.",
-      isWin
-    }
+    const parsed = JSON.parse(localStorage.getItem(DEFINITION_CACHE_KEY))
+    return parsed && typeof parsed === "object" ? parsed : {}
+  } catch {
+    return {}
   }
+}
+
+function saveDefinitionToCache(word, entry) {
+  try {
+    const cache = readDefinitionCache()
+    cache[word.toLowerCase()] = { ...entry, cachedAt: Date.now() }
+    const trimmed = Object.entries(cache)
+      .sort((a, b) => (b[1].cachedAt || 0) - (a[1].cachedAt || 0))
+      .slice(0, DEFINITION_CACHE_LIMIT)
+    localStorage.setItem(DEFINITION_CACHE_KEY, JSON.stringify(Object.fromEntries(trimmed)))
+  } catch {
+  }
+}
+
+function stripDefinitionHtml(value) {
+  return String(value ?? "")
+    .replace(/<[^>]*>/g, "")
+    .replaceAll("&nbsp;", " ")
+    .replace(/\s+/g, " ")
+    .trim()
+}
+
+async function fetchDictionaryApiDefinition(word) {
+  const response = await fetch(`https://api.dictionaryapi.dev/api/v2/entries/en/${encodeURIComponent(word)}`)
+  if (!response.ok) {
+    const error = new Error(`API request failed: ${response.status}`)
+    error.status = response.status
+    throw error
+  }
+
+  const data = await response.json()
+  const entry = data.find(item => Array.isArray(item.meanings) && item.meanings.length > 0) || data[0]
+  const firstMeaning = entry?.meanings?.[0]
+  const definition = firstMeaning?.definitions?.[0]?.definition
+
+  if (!definition) throw new Error("No definition found")
+
+  return {
+    title: `${word.toUpperCase()} ${firstMeaning.partOfSpeech ? `(${firstMeaning.partOfSpeech})` : ""}`,
+    body: definition,
+    example: firstMeaning.definitions?.[0]?.example || undefined
+  }
+}
+
+async function fetchWiktionaryDefinition(word) {
+  const response = await fetch(`https://en.wiktionary.org/api/rest_v1/page/definition/${encodeURIComponent(word)}`)
+  if (!response.ok) {
+    const error = new Error(`Wiktionary request failed: ${response.status}`)
+    error.status = response.status
+    throw error
+  }
+
+  const data = await response.json()
+  const englishEntries = Array.isArray(data?.en) ? data.en : []
+  const entry = englishEntries.find(item => Array.isArray(item.definitions) && item.definitions.length > 0)
+  const definitionBlock = entry?.definitions.find(item => stripDefinitionHtml(item.definition))
+  const definition = stripDefinitionHtml(definitionBlock?.definition)
+
+  if (!definition) throw new Error("No definition found")
+
+  const rawExample = definitionBlock.parsedExamples?.[0]?.example ?? definitionBlock.examples?.[0]
+  return {
+    title: `${word.toUpperCase()} ${entry.partOfSpeech ? `(${String(entry.partOfSpeech).toLowerCase()})` : ""}`,
+    body: definition,
+    example: stripDefinitionHtml(rawExample) || undefined
+  }
+}
+
+function waitForDuration(duration) {
+  return new Promise(resolve => setTimeout(resolve, duration))
+}
+
+async function loadWordDefinition(word, isWin = true) {
+  lastDefinition = null
+  renderStatsDefinition()
+  renderLeaderboardResult()
+
+  let definitionEntry = null
+  const cached = readDefinitionCache()[word.toLowerCase()]
+  if (cached?.body) {
+    definitionEntry = { ...cached }
+  } else {
+    try {
+      definitionEntry = await fetchDictionaryApiDefinition(word)
+    } catch (error) {
+      console.info("Primary definition lookup failed:", error)
+      if (error.status !== 404) {
+        await waitForDuration(DEFINITION_RETRY_DELAY_MS)
+        try {
+          definitionEntry = await fetchDictionaryApiDefinition(word)
+        } catch (retryError) {
+          console.info("Primary definition retry failed:", retryError)
+        }
+      }
+    }
+
+    if (!definitionEntry) {
+      try {
+        definitionEntry = await fetchWiktionaryDefinition(word)
+      } catch (error) {
+        console.info("Fallback definition lookup failed:", error)
+      }
+    }
+
+    if (definitionEntry) saveDefinitionToCache(word, definitionEntry)
+  }
+
+  lastDefinition = definitionEntry
+    ? { ...definitionEntry, isWin }
+    : {
+        title: word.toUpperCase(),
+        body: "Definition not available at the moment.",
+        isWin
+      }
 
   renderStatsDefinition()
   renderLeaderboardResult()
