tdk-api-wrapper 1.2.0 → 1.2.2

package/README.md

@@ -68,7 +68,7 @@ Aşağıdaki metotlar `TDK` sınıfı üzerinden statik olarak erişilebilir dur
 - **`TDK.syllabicate(word)`**: Kelimeyi Türkçe heceleme kurallarına göre doğru hecelerine ayırır (Örn: `['mu', 'vaf', 'fa', 'ki', 'yet']`). API isteği atmaz, çok hızlıdır.
 - **`TDK.checkVowelHarmony(word)`**: Kelimenin büyük ünlü uyumuna uyup uymadığını (boolean) kontrol eder.
 - **`TDK.getPartOfSpeech(word)`**: Kelimenin sözcük türünü (isim, sıfat, zarf vb.) döndürür.
-- **`TDK.checkSpelling(word)`**: Sıkça yapılan yanlışlar listesini ve TDK veritabanını kullanarak kelimenin doğru yazılıp yazılmadığını kontrol eder. Yanlışsa doğrusunu önerir; tam eşleşme yoksa, aynı listedeki kelimeler arasında edit-distance (Levenshtein) ile en yakınını önerir (not: tüm sözlükte değil, yalnızca bu küçük havuzda arama yapar).
+- **`TDK.checkSpelling(word)`**: Kelimenin doğru yazılıp yazılmadığını kontrol eder. Önce TDK'nin "sık yapılan yanlışlar" listesinde tam eşleşme arar; bulamazsa TDK'nin ~81 bin kelimelik tam madde listesi üzerinde Damerau-Levenshtein edit-distance ile en yakın kelimeyi önerir (bitişik harf yer değiştirmelerini de tek düzeltme sayar; örn. `herkez` → `herkes`, `mektub` → `mektup`, `yanlız` → `yalnız`). Kelime sıklığı verisi olmadığı için nadiren aynı mesafedeki iki aday arasında beklenenden farklı biri seçilebilir.
 - **`TDK.getCompoundWords(word)`**: Aranan kelime ile oluşturulmuş birleşik kelimeleri (Örn: dolma kalem) listeler.
 
 ### 3. Edebi ve Kültürel Analiz
@@ -79,7 +79,7 @@ Aşağıdaki metotlar `TDK` sınıfı üzerinden statik olarak erişilebilir dur
 - **`TDK.groupByOrigin(words)`**: Bir kelime listesini etimolojik kökenlerine göre gruplar (bulunamayanlar `"Bilinmiyor"` altında toplanır).
 - **`TDK.getSynonyms(word)`** / **`TDK.getAntonyms(word)`**: Kelimenin eş/zıt anlamlılarını döner (undocumented `gts-yeni` endpoint'i üzerinden; sonuç bulunamazsa `[]`).
 - **`TDK.compareWords(a, b)`**: İki kelimeyi anlam sayısı, köken, hece bölünüşü ve büyük ünlü uyumu açısından yan yana karşılaştırır.
-- **`TDK.analyzeText(text)`**: Bir metindeki (Türkçe bağlaçlar/edatlar hariç) her benzersiz kelimeyi tek tek arayıp ilk anlamını ve kökenini döner.
+- **`TDK.analyzeText(text)`**: Bir metindeki (Türkçe bağlaçlar/edatlar hariç) her benzersiz kelimeyi tek tek arayıp ilk anlamını ve kökenini döner. Not: TDK yalnızca yalın (sözlük) biçimleri indeksliyor, morfolojik analiz yapmıyor — bu yüzden "evde", "dildir" gibi ek almış kelimeler kökleri (`ev`, `dil`) sözlükte olsa bile `found: false` döner; bu veri kaynağının doğal bir sınırlılığıdır.
 
 ### 4. Yardımcı Metotlar
 - **`TDK.getSuggestions(prefix)`**: TDK'nin ~81 bin kelimelik tam madde listesi üzerinden önek bazlı otomatik tamamlama önerileri döner (ilk çağrıda listeyi indirip önbelleğe alır, sonraki çağrılar anlıktır).
@@ -88,7 +88,7 @@ Aşağıdaki metotlar `TDK` sınıfı üzerinden statik olarak erişilebilir dur
 - **`TDK.getWordOfTheDay()`**: `getDailyContent()`'in üzerine ince bir katman; günün kelimesini ve tüm anlamlarını `{ word, meanings }` şeklinde döner.
 - **`TDK.getRandomWord()`**: Günün içeriğindeki kelime ve atasözü havuzundan rastgele bir tanesini `{ type: "kelime" | "atasoz", madde, anlam }` şeklinde seçer (not: tüm sözlük değil, sadece o günkü içerik havuzundan seçim yapar).
 - **`TDK.getKurallar()`**: TDK'nin `/icerik` akışının o an döndürdüğü yazım kuralı sayfa(lar)ını `{ adi, url }` şeklinde listeler. Not: bu sabit bir katalog değildir — `/icerik` her istekte, yaklaşık yirmi kurallık bir havuzdan rastgele tek bir kural döndürür.
-- **`TDK.getRule(name)`**: Adı verilen (küçük/büyük harf duyarsız, alt dize eşleşmesi) yazım kuralının tam metnini `tdk.gov.tr`'den çekip düz metne çevirir. `getKurallar()`'ın rastgeleliği yüzünden istenen kuralı bulana kadar sınırlı sayıda (en fazla 25, aralarda kısa bekleme ile) yeniden dener; bulamazsa veya sayfa ayrıştırılamazsa `null` döner.
+- **`TDK.getRule(name)`**: Adı verilen (küçük/büyük harf duyarsız, alt dize eşleşmesi) yazım kuralının tam metnini `tdk.gov.tr`'den çekip düz metne çevirir. `getKurallar()`'ın rastgeleliği yüzünden istenen kuralı bulana kadar eşzamanlı gruplar hâlinde (toplam en fazla 25 deneme, ~5 round-trip'e sığdırılmış) yeniden dener; bulamazsa veya sayfa ayrıştırılamazsa `null` döner.
 
 ## Hata Yönetimi
 

package/dist/{chunk-2TA5PMVZ.mjs → chunk-SNY3KUCF.mjs}

@@ -390,29 +390,42 @@ var TDK = class {
       if (mixMatch) {
         return { isCorrect: false, word, suggestion: mixMatch.dogru };
       }
-      const candidates = [
-        ...daily.syyd.map((s) => s.dogrukelime),
-        ...daily.karistirma.flatMap((s) => [s.yanlis, s.dogru]),
-        ...daily.kelime.map((k) => k.madde)
-      ];
-      let best = null;
-      for (const candidate of candidates) {
-        const distance = this.levenshtein(word.toLocaleLowerCase("tr-TR"), candidate.toLocaleLowerCase("tr-TR"));
-        if (distance > 0 && (!best || distance < best.distance)) {
-          best = { candidate, distance };
-        }
-      }
-      if (best && best.distance <= 2) {
-        return { isCorrect: false, word, suggestion: best.candidate };
+    }
+    if (this.autocompleteCache.length === 0) {
+      this.autocompleteCache = await this.fetchAutocompleteData();
+    }
+    const cleanWord = word.trim().toLocaleLowerCase("tr-TR");
+    let best = null;
+    for (const candidate of this.autocompleteCache) {
+      if (candidate.includes(" ") || candidate !== candidate.toLocaleLowerCase("tr-TR"))
+        continue;
+      if (Math.abs(candidate.length - cleanWord.length) > 2)
+        continue;
+      const distance = this.damerauLevenshtein(cleanWord, candidate);
+      if (distance === 0)
+        continue;
+      const firstMismatch = candidate[0] === cleanWord[0] ? 0 : 1;
+      const lengthMismatch = candidate.length === cleanWord.length ? 0 : 1;
+      const better = !best || distance < best.distance || distance === best.distance && firstMismatch < best.firstMismatch || distance === best.distance && firstMismatch === best.firstMismatch && lengthMismatch < best.lengthMismatch;
+      if (better) {
+        best = { candidate, distance, firstMismatch, lengthMismatch };
       }
     }
+    if (best && best.distance <= 2) {
+      return { isCorrect: false, word, suggestion: best.candidate };
+    }
     return { isCorrect: false, word };
   }
   /**
    * Fetches daily content (word of the day, proverbs, rules, etc).
+   * `bypassCache` skips both reading and writing `dailyContentCache` even
+   * when `enableCache(true)` is on — used by `getRule()`'s retry loop, which
+   * needs a fresh random `/icerik` draw on every attempt; without it, once
+   * caching is enabled the loop would just re-read the same cached response
+   * 25 times and could never find a rule outside that first random draw.
    */
-  static async getDailyContent() {
-    if (this.isCacheEnabled && this.dailyContentCache)
+  static async getDailyContent(bypassCache = false) {
+    if (!bypassCache && this.isCacheEnabled && this.dailyContentCache)
       return this.dailyContentCache;
     try {
       const response = await fetch(`${this.BASE_URL}/icerik`, {
@@ -420,7 +433,7 @@ var TDK = class {
       });
       if (response.ok) {
         const data = await response.json();
-        if (this.isCacheEnabled)
+        if (!bypassCache && this.isCacheEnabled)
           this.dailyContentCache = data;
         return data;
       }
@@ -461,10 +474,12 @@ var TDK = class {
    * `/icerik` daily-content feed, e.g. `{ adi: "Kısaltmalar", url: "https://..." }`.
    * Note: like `getRandomWord()`, this is NOT a fixed catalog — `/icerik`
    * appears to hand back a single randomly-rotated rule per request, so two
-   * calls a second apart can return entirely different rules.
+   * calls a second apart can return entirely different rules. `bypassCache`
+   * (used internally by `getRule()`'s retry loop) forces a fresh `/icerik`
+   * draw even when `enableCache(true)` is on.
    */
-  static async getKurallar() {
-    const daily = await this.getDailyContent();
+  static async getKurallar(bypassCache = false) {
+    const daily = await this.getDailyContent(bypassCache);
     return daily?.kural ?? [];
   }
   /**
@@ -472,21 +487,33 @@ var TDK = class {
    * case-insensitively, substring match) from `tdk.gov.tr`. Since `/icerik`
    * hands back a single randomly-rotated rule per request (out of a pool of
    * roughly twenty) rather than a fixed catalog, a single `getKurallar()`
-   * draw would rarely match a given name — this re-draws (bounded, with a
-   * short delay) until it finds a match or gives up. Returns `null` if no
-   * match turns up within the attempt budget or the matched page can't be
-   * parsed.
+   * draw would rarely match a given name — this re-draws until it finds a
+   * match or gives up. Draws happen in concurrent batches (each `/icerik`
+   * request is independent and stateless) rather than one-at-a-time with a
+   * delay: same total sample size (25) and hit probability as a sequential
+   * loop, but bounded to a handful of round-trips instead of 25 of them, so
+   * a miss resolves in roughly one round-trip time instead of several
+   * seconds. Every draw bypasses `dailyContentCache` — without that, once
+   * `enableCache(true)` is on, every attempt would just re-read the same
+   * cached `/icerik` response and could never find a rule outside whatever
+   * the first draw happened to be. Returns `null` if no match turns up
+   * within the attempt budget or the matched page can't be parsed.
    */
   static async getRule(name) {
     if (!name || name.trim() === "")
       return null;
     const target = name.trim().toLocaleLowerCase("tr-TR");
-    for (let attempt = 0; attempt < 25; attempt++) {
-      const rules = await this.getKurallar();
-      const match = rules.find((r) => r.adi.toLocaleLowerCase("tr-TR").includes(target));
-      if (match)
-        return this.fetchRuleText(match.url);
-      await this.delay(100);
+    const BATCH_SIZE = 5;
+    const ROUNDS = 5;
+    for (let round = 0; round < ROUNDS; round++) {
+      const batches = await Promise.all(
+        Array.from({ length: BATCH_SIZE }, () => this.getKurallar(true))
+      );
+      for (const rules of batches) {
+        const match = rules.find((r) => r.adi.toLocaleLowerCase("tr-TR").includes(target));
+        if (match)
+          return this.fetchRuleText(match.url);
+      }
     }
     return null;
   }
@@ -634,6 +661,11 @@ var TDK = class {
    * Analyzes every distinct word in a text (Turkish stopwords filtered out),
    * returning each word's first meaning and etymological origin if found.
    * Looks each word up individually (throttled), so scales with text length.
+   * TDK only indexes dictionary (dictionary/root) forms, not inflected ones —
+   * it does no morphological analysis, and neither does this method: a
+   * suffixed word like "evde" or "dildir" (root "ev"/"dil" plus a case/verb
+   * suffix) will come back `found: false` even though the root is a real
+   * headword. This is an inherent limitation of the data source, not a bug.
    */
   static async analyzeText(text) {
     const words = text.toLocaleLowerCase("tr-TR").replace(/[^\p{L}\s]/gu, " ").split(/\s+/).filter((w) => w.length > 1 && !this.STOPWORDS.has(w));
@@ -653,9 +685,13 @@ var TDK = class {
     return analyses;
   }
   /**
-   * Classic edit-distance between two strings.
+   * Damerau-Levenshtein edit-distance (optimal string alignment variant):
+   * like classic Levenshtein but also counts an adjacent-character
+   * transposition (e.g. "yanlız" -> "yalnız") as a single edit instead of
+   * two substitutions — a very common class of typo that plain Levenshtein
+   * otherwise misses.
    */
-  static levenshtein(a, b) {
+  static damerauLevenshtein(a, b) {
     const dp = Array.from({ length: a.length + 1 }, () => new Array(b.length + 1).fill(0));
     for (let i = 0; i <= a.length; i++)
       dp[i][0] = i;
@@ -665,6 +701,9 @@ var TDK = class {
       for (let j = 1; j <= b.length; j++) {
         const cost = a[i - 1] === b[j - 1] ? 0 : 1;
         dp[i][j] = Math.min(dp[i - 1][j] + 1, dp[i][j - 1] + 1, dp[i - 1][j - 1] + cost);
+        if (i > 1 && j > 1 && a[i - 1] === b[j - 2] && a[i - 2] === b[j - 1]) {
+          dp[i][j] = Math.min(dp[i][j], dp[i - 2][j - 2] + cost);
+        }
       }
     }
     return dp[a.length][b.length];

package/dist/cli.js

@@ -415,29 +415,42 @@ var TDK = class {
       if (mixMatch) {
         return { isCorrect: false, word: word2, suggestion: mixMatch.dogru };
       }
-      const candidates = [
-        ...daily.syyd.map((s) => s.dogrukelime),
-        ...daily.karistirma.flatMap((s) => [s.yanlis, s.dogru]),
-        ...daily.kelime.map((k) => k.madde)
-      ];
-      let best = null;
-      for (const candidate of candidates) {
-        const distance = this.levenshtein(word2.toLocaleLowerCase("tr-TR"), candidate.toLocaleLowerCase("tr-TR"));
-        if (distance > 0 && (!best || distance < best.distance)) {
-          best = { candidate, distance };
-        }
-      }
-      if (best && best.distance <= 2) {
-        return { isCorrect: false, word: word2, suggestion: best.candidate };
+    }
+    if (this.autocompleteCache.length === 0) {
+      this.autocompleteCache = await this.fetchAutocompleteData();
+    }
+    const cleanWord = word2.trim().toLocaleLowerCase("tr-TR");
+    let best = null;
+    for (const candidate of this.autocompleteCache) {
+      if (candidate.includes(" ") || candidate !== candidate.toLocaleLowerCase("tr-TR"))
+        continue;
+      if (Math.abs(candidate.length - cleanWord.length) > 2)
+        continue;
+      const distance = this.damerauLevenshtein(cleanWord, candidate);
+      if (distance === 0)
+        continue;
+      const firstMismatch = candidate[0] === cleanWord[0] ? 0 : 1;
+      const lengthMismatch = candidate.length === cleanWord.length ? 0 : 1;
+      const better = !best || distance < best.distance || distance === best.distance && firstMismatch < best.firstMismatch || distance === best.distance && firstMismatch === best.firstMismatch && lengthMismatch < best.lengthMismatch;
+      if (better) {
+        best = { candidate, distance, firstMismatch, lengthMismatch };
       }
     }
+    if (best && best.distance <= 2) {
+      return { isCorrect: false, word: word2, suggestion: best.candidate };
+    }
     return { isCorrect: false, word: word2 };
   }
   /**
    * Fetches daily content (word of the day, proverbs, rules, etc).
+   * `bypassCache` skips both reading and writing `dailyContentCache` even
+   * when `enableCache(true)` is on — used by `getRule()`'s retry loop, which
+   * needs a fresh random `/icerik` draw on every attempt; without it, once
+   * caching is enabled the loop would just re-read the same cached response
+   * 25 times and could never find a rule outside that first random draw.
    */
-  static async getDailyContent() {
-    if (this.isCacheEnabled && this.dailyContentCache)
+  static async getDailyContent(bypassCache = false) {
+    if (!bypassCache && this.isCacheEnabled && this.dailyContentCache)
       return this.dailyContentCache;
     try {
       const response = await fetch(`${this.BASE_URL}/icerik`, {
@@ -445,7 +458,7 @@ var TDK = class {
       });
       if (response.ok) {
         const data = await response.json();
-        if (this.isCacheEnabled)
+        if (!bypassCache && this.isCacheEnabled)
           this.dailyContentCache = data;
         return data;
       }
@@ -486,10 +499,12 @@ var TDK = class {
    * `/icerik` daily-content feed, e.g. `{ adi: "Kısaltmalar", url: "https://..." }`.
    * Note: like `getRandomWord()`, this is NOT a fixed catalog — `/icerik`
    * appears to hand back a single randomly-rotated rule per request, so two
-   * calls a second apart can return entirely different rules.
+   * calls a second apart can return entirely different rules. `bypassCache`
+   * (used internally by `getRule()`'s retry loop) forces a fresh `/icerik`
+   * draw even when `enableCache(true)` is on.
    */
-  static async getKurallar() {
-    const daily = await this.getDailyContent();
+  static async getKurallar(bypassCache = false) {
+    const daily = await this.getDailyContent(bypassCache);
     return daily?.kural ?? [];
   }
   /**
@@ -497,21 +512,33 @@ var TDK = class {
    * case-insensitively, substring match) from `tdk.gov.tr`. Since `/icerik`
    * hands back a single randomly-rotated rule per request (out of a pool of
    * roughly twenty) rather than a fixed catalog, a single `getKurallar()`
-   * draw would rarely match a given name — this re-draws (bounded, with a
-   * short delay) until it finds a match or gives up. Returns `null` if no
-   * match turns up within the attempt budget or the matched page can't be
-   * parsed.
+   * draw would rarely match a given name — this re-draws until it finds a
+   * match or gives up. Draws happen in concurrent batches (each `/icerik`
+   * request is independent and stateless) rather than one-at-a-time with a
+   * delay: same total sample size (25) and hit probability as a sequential
+   * loop, but bounded to a handful of round-trips instead of 25 of them, so
+   * a miss resolves in roughly one round-trip time instead of several
+   * seconds. Every draw bypasses `dailyContentCache` — without that, once
+   * `enableCache(true)` is on, every attempt would just re-read the same
+   * cached `/icerik` response and could never find a rule outside whatever
+   * the first draw happened to be. Returns `null` if no match turns up
+   * within the attempt budget or the matched page can't be parsed.
    */
   static async getRule(name) {
     if (!name || name.trim() === "")
       return null;
     const target = name.trim().toLocaleLowerCase("tr-TR");
-    for (let attempt = 0; attempt < 25; attempt++) {
-      const rules = await this.getKurallar();
-      const match = rules.find((r) => r.adi.toLocaleLowerCase("tr-TR").includes(target));
-      if (match)
-        return this.fetchRuleText(match.url);
-      await this.delay(100);
+    const BATCH_SIZE = 5;
+    const ROUNDS = 5;
+    for (let round = 0; round < ROUNDS; round++) {
+      const batches = await Promise.all(
+        Array.from({ length: BATCH_SIZE }, () => this.getKurallar(true))
+      );
+      for (const rules of batches) {
+        const match = rules.find((r) => r.adi.toLocaleLowerCase("tr-TR").includes(target));
+        if (match)
+          return this.fetchRuleText(match.url);
+      }
     }
     return null;
   }
@@ -659,6 +686,11 @@ var TDK = class {
    * Analyzes every distinct word in a text (Turkish stopwords filtered out),
    * returning each word's first meaning and etymological origin if found.
    * Looks each word up individually (throttled), so scales with text length.
+   * TDK only indexes dictionary (dictionary/root) forms, not inflected ones —
+   * it does no morphological analysis, and neither does this method: a
+   * suffixed word like "evde" or "dildir" (root "ev"/"dil" plus a case/verb
+   * suffix) will come back `found: false` even though the root is a real
+   * headword. This is an inherent limitation of the data source, not a bug.
    */
   static async analyzeText(text) {
     const words = text.toLocaleLowerCase("tr-TR").replace(/[^\p{L}\s]/gu, " ").split(/\s+/).filter((w) => w.length > 1 && !this.STOPWORDS.has(w));
@@ -678,9 +710,13 @@ var TDK = class {
     return analyses;
   }
   /**
-   * Classic edit-distance between two strings.
+   * Damerau-Levenshtein edit-distance (optimal string alignment variant):
+   * like classic Levenshtein but also counts an adjacent-character
+   * transposition (e.g. "yanlız" -> "yalnız") as a single edit instead of
+   * two substitutions — a very common class of typo that plain Levenshtein
+   * otherwise misses.
    */
-  static levenshtein(a, b) {
+  static damerauLevenshtein(a, b) {
     const dp = Array.from({ length: a.length + 1 }, () => new Array(b.length + 1).fill(0));
     for (let i = 0; i <= a.length; i++)
       dp[i][0] = i;
@@ -690,6 +726,9 @@ var TDK = class {
       for (let j = 1; j <= b.length; j++) {
         const cost = a[i - 1] === b[j - 1] ? 0 : 1;
         dp[i][j] = Math.min(dp[i - 1][j] + 1, dp[i][j - 1] + 1, dp[i - 1][j - 1] + cost);
+        if (i > 1 && j > 1 && a[i - 1] === b[j - 2] && a[i - 2] === b[j - 1]) {
+          dp[i][j] = Math.min(dp[i][j], dp[i - 2][j - 2] + cost);
+        }
       }
     }
     return dp[a.length][b.length];

package/dist/cli.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   TDK
-} from "./chunk-2TA5PMVZ.mjs";
+} from "./chunk-SNY3KUCF.mjs";
 
 // src/cli.ts
 var rawArgs = process.argv.slice(2);

package/dist/index.d.mts

@@ -244,8 +244,13 @@ declare class TDK {
     static checkSpelling(word: string): Promise<SpellCheckResult>;
     /**
      * Fetches daily content (word of the day, proverbs, rules, etc).
+     * `bypassCache` skips both reading and writing `dailyContentCache` even
+     * when `enableCache(true)` is on — used by `getRule()`'s retry loop, which
+     * needs a fresh random `/icerik` draw on every attempt; without it, once
+     * caching is enabled the loop would just re-read the same cached response
+     * 25 times and could never find a rule outside that first random draw.
      */
-    static getDailyContent(): Promise<DailyContent | null>;
+    static getDailyContent(bypassCache?: boolean): Promise<DailyContent | null>;
     /**
      * Returns today's word of the day along with all of its listed meanings.
      */
@@ -260,18 +265,27 @@ declare class TDK {
      * `/icerik` daily-content feed, e.g. `{ adi: "Kısaltmalar", url: "https://..." }`.
      * Note: like `getRandomWord()`, this is NOT a fixed catalog — `/icerik`
      * appears to hand back a single randomly-rotated rule per request, so two
-     * calls a second apart can return entirely different rules.
+     * calls a second apart can return entirely different rules. `bypassCache`
+     * (used internally by `getRule()`'s retry loop) forces a fresh `/icerik`
+     * draw even when `enableCache(true)` is on.
      */
-    static getKurallar(): Promise<TDKRule[]>;
+    static getKurallar(bypassCache?: boolean): Promise<TDKRule[]>;
     /**
      * Fetches the full plain-text content of a named spelling rule (matched
      * case-insensitively, substring match) from `tdk.gov.tr`. Since `/icerik`
      * hands back a single randomly-rotated rule per request (out of a pool of
      * roughly twenty) rather than a fixed catalog, a single `getKurallar()`
-     * draw would rarely match a given name — this re-draws (bounded, with a
-     * short delay) until it finds a match or gives up. Returns `null` if no
-     * match turns up within the attempt budget or the matched page can't be
-     * parsed.
+     * draw would rarely match a given name — this re-draws until it finds a
+     * match or gives up. Draws happen in concurrent batches (each `/icerik`
+     * request is independent and stateless) rather than one-at-a-time with a
+     * delay: same total sample size (25) and hit probability as a sequential
+     * loop, but bounded to a handful of round-trips instead of 25 of them, so
+     * a miss resolves in roughly one round-trip time instead of several
+     * seconds. Every draw bypasses `dailyContentCache` — without that, once
+     * `enableCache(true)` is on, every attempt would just re-read the same
+     * cached `/icerik` response and could never find a rule outside whatever
+     * the first draw happened to be. Returns `null` if no match turns up
+     * within the attempt budget or the matched page can't be parsed.
      */
     static getRule(name: string): Promise<string | null>;
     /**
@@ -304,12 +318,21 @@ declare class TDK {
      * Analyzes every distinct word in a text (Turkish stopwords filtered out),
      * returning each word's first meaning and etymological origin if found.
      * Looks each word up individually (throttled), so scales with text length.
+     * TDK only indexes dictionary (dictionary/root) forms, not inflected ones —
+     * it does no morphological analysis, and neither does this method: a
+     * suffixed word like "evde" or "dildir" (root "ev"/"dil" plus a case/verb
+     * suffix) will come back `found: false` even though the root is a real
+     * headword. This is an inherent limitation of the data source, not a bug.
      */
     static analyzeText(text: string): Promise<WordAnalysis[]>;
     /**
-     * Classic edit-distance between two strings.
+     * Damerau-Levenshtein edit-distance (optimal string alignment variant):
+     * like classic Levenshtein but also counts an adjacent-character
+     * transposition (e.g. "yanlız" -> "yalnız") as a single edit instead of
+     * two substitutions — a very common class of typo that plain Levenshtein
+     * otherwise misses.
      */
-    private static levenshtein;
+    private static damerauLevenshtein;
     /**
      * Fetches multiple words concurrently with a small delay to avoid rate limiting.
      */

package/dist/index.d.ts

@@ -244,8 +244,13 @@ declare class TDK {
     static checkSpelling(word: string): Promise<SpellCheckResult>;
     /**
      * Fetches daily content (word of the day, proverbs, rules, etc).
+     * `bypassCache` skips both reading and writing `dailyContentCache` even
+     * when `enableCache(true)` is on — used by `getRule()`'s retry loop, which
+     * needs a fresh random `/icerik` draw on every attempt; without it, once
+     * caching is enabled the loop would just re-read the same cached response
+     * 25 times and could never find a rule outside that first random draw.
      */
-    static getDailyContent(): Promise<DailyContent | null>;
+    static getDailyContent(bypassCache?: boolean): Promise<DailyContent | null>;
     /**
      * Returns today's word of the day along with all of its listed meanings.
      */
@@ -260,18 +265,27 @@ declare class TDK {
      * `/icerik` daily-content feed, e.g. `{ adi: "Kısaltmalar", url: "https://..." }`.
      * Note: like `getRandomWord()`, this is NOT a fixed catalog — `/icerik`
      * appears to hand back a single randomly-rotated rule per request, so two
-     * calls a second apart can return entirely different rules.
+     * calls a second apart can return entirely different rules. `bypassCache`
+     * (used internally by `getRule()`'s retry loop) forces a fresh `/icerik`
+     * draw even when `enableCache(true)` is on.
      */
-    static getKurallar(): Promise<TDKRule[]>;
+    static getKurallar(bypassCache?: boolean): Promise<TDKRule[]>;
     /**
      * Fetches the full plain-text content of a named spelling rule (matched
      * case-insensitively, substring match) from `tdk.gov.tr`. Since `/icerik`
      * hands back a single randomly-rotated rule per request (out of a pool of
      * roughly twenty) rather than a fixed catalog, a single `getKurallar()`
-     * draw would rarely match a given name — this re-draws (bounded, with a
-     * short delay) until it finds a match or gives up. Returns `null` if no
-     * match turns up within the attempt budget or the matched page can't be
-     * parsed.
+     * draw would rarely match a given name — this re-draws until it finds a
+     * match or gives up. Draws happen in concurrent batches (each `/icerik`
+     * request is independent and stateless) rather than one-at-a-time with a
+     * delay: same total sample size (25) and hit probability as a sequential
+     * loop, but bounded to a handful of round-trips instead of 25 of them, so
+     * a miss resolves in roughly one round-trip time instead of several
+     * seconds. Every draw bypasses `dailyContentCache` — without that, once
+     * `enableCache(true)` is on, every attempt would just re-read the same
+     * cached `/icerik` response and could never find a rule outside whatever
+     * the first draw happened to be. Returns `null` if no match turns up
+     * within the attempt budget or the matched page can't be parsed.
      */
     static getRule(name: string): Promise<string | null>;
     /**
@@ -304,12 +318,21 @@ declare class TDK {
      * Analyzes every distinct word in a text (Turkish stopwords filtered out),
      * returning each word's first meaning and etymological origin if found.
      * Looks each word up individually (throttled), so scales with text length.
+     * TDK only indexes dictionary (dictionary/root) forms, not inflected ones —
+     * it does no morphological analysis, and neither does this method: a
+     * suffixed word like "evde" or "dildir" (root "ev"/"dil" plus a case/verb
+     * suffix) will come back `found: false` even though the root is a real
+     * headword. This is an inherent limitation of the data source, not a bug.
      */
     static analyzeText(text: string): Promise<WordAnalysis[]>;
     /**
-     * Classic edit-distance between two strings.
+     * Damerau-Levenshtein edit-distance (optimal string alignment variant):
+     * like classic Levenshtein but also counts an adjacent-character
+     * transposition (e.g. "yanlız" -> "yalnız") as a single edit instead of
+     * two substitutions — a very common class of typo that plain Levenshtein
+     * otherwise misses.
      */
-    private static levenshtein;
+    private static damerauLevenshtein;
     /**
      * Fetches multiple words concurrently with a small delay to avoid rate limiting.
      */

package/dist/index.js

@@ -429,29 +429,42 @@ var TDK = class {
       if (mixMatch) {
         return { isCorrect: false, word, suggestion: mixMatch.dogru };
       }
-      const candidates = [
-        ...daily.syyd.map((s) => s.dogrukelime),
-        ...daily.karistirma.flatMap((s) => [s.yanlis, s.dogru]),
-        ...daily.kelime.map((k) => k.madde)
-      ];
-      let best = null;
-      for (const candidate of candidates) {
-        const distance = this.levenshtein(word.toLocaleLowerCase("tr-TR"), candidate.toLocaleLowerCase("tr-TR"));
-        if (distance > 0 && (!best || distance < best.distance)) {
-          best = { candidate, distance };
-        }
-      }
-      if (best && best.distance <= 2) {
-        return { isCorrect: false, word, suggestion: best.candidate };
+    }
+    if (this.autocompleteCache.length === 0) {
+      this.autocompleteCache = await this.fetchAutocompleteData();
+    }
+    const cleanWord = word.trim().toLocaleLowerCase("tr-TR");
+    let best = null;
+    for (const candidate of this.autocompleteCache) {
+      if (candidate.includes(" ") || candidate !== candidate.toLocaleLowerCase("tr-TR"))
+        continue;
+      if (Math.abs(candidate.length - cleanWord.length) > 2)
+        continue;
+      const distance = this.damerauLevenshtein(cleanWord, candidate);
+      if (distance === 0)
+        continue;
+      const firstMismatch = candidate[0] === cleanWord[0] ? 0 : 1;
+      const lengthMismatch = candidate.length === cleanWord.length ? 0 : 1;
+      const better = !best || distance < best.distance || distance === best.distance && firstMismatch < best.firstMismatch || distance === best.distance && firstMismatch === best.firstMismatch && lengthMismatch < best.lengthMismatch;
+      if (better) {
+        best = { candidate, distance, firstMismatch, lengthMismatch };
       }
     }
+    if (best && best.distance <= 2) {
+      return { isCorrect: false, word, suggestion: best.candidate };
+    }
     return { isCorrect: false, word };
   }
   /**
    * Fetches daily content (word of the day, proverbs, rules, etc).
+   * `bypassCache` skips both reading and writing `dailyContentCache` even
+   * when `enableCache(true)` is on — used by `getRule()`'s retry loop, which
+   * needs a fresh random `/icerik` draw on every attempt; without it, once
+   * caching is enabled the loop would just re-read the same cached response
+   * 25 times and could never find a rule outside that first random draw.
    */
-  static async getDailyContent() {
-    if (this.isCacheEnabled && this.dailyContentCache)
+  static async getDailyContent(bypassCache = false) {
+    if (!bypassCache && this.isCacheEnabled && this.dailyContentCache)
       return this.dailyContentCache;
     try {
       const response = await fetch(`${this.BASE_URL}/icerik`, {
@@ -459,7 +472,7 @@ var TDK = class {
       });
       if (response.ok) {
         const data = await response.json();
-        if (this.isCacheEnabled)
+        if (!bypassCache && this.isCacheEnabled)
           this.dailyContentCache = data;
         return data;
       }
@@ -500,10 +513,12 @@ var TDK = class {
    * `/icerik` daily-content feed, e.g. `{ adi: "Kısaltmalar", url: "https://..." }`.
    * Note: like `getRandomWord()`, this is NOT a fixed catalog — `/icerik`
    * appears to hand back a single randomly-rotated rule per request, so two
-   * calls a second apart can return entirely different rules.
+   * calls a second apart can return entirely different rules. `bypassCache`
+   * (used internally by `getRule()`'s retry loop) forces a fresh `/icerik`
+   * draw even when `enableCache(true)` is on.
    */
-  static async getKurallar() {
-    const daily = await this.getDailyContent();
+  static async getKurallar(bypassCache = false) {
+    const daily = await this.getDailyContent(bypassCache);
     return daily?.kural ?? [];
   }
   /**
@@ -511,21 +526,33 @@ var TDK = class {
    * case-insensitively, substring match) from `tdk.gov.tr`. Since `/icerik`
    * hands back a single randomly-rotated rule per request (out of a pool of
    * roughly twenty) rather than a fixed catalog, a single `getKurallar()`
-   * draw would rarely match a given name — this re-draws (bounded, with a
-   * short delay) until it finds a match or gives up. Returns `null` if no
-   * match turns up within the attempt budget or the matched page can't be
-   * parsed.
+   * draw would rarely match a given name — this re-draws until it finds a
+   * match or gives up. Draws happen in concurrent batches (each `/icerik`
+   * request is independent and stateless) rather than one-at-a-time with a
+   * delay: same total sample size (25) and hit probability as a sequential
+   * loop, but bounded to a handful of round-trips instead of 25 of them, so
+   * a miss resolves in roughly one round-trip time instead of several
+   * seconds. Every draw bypasses `dailyContentCache` — without that, once
+   * `enableCache(true)` is on, every attempt would just re-read the same
+   * cached `/icerik` response and could never find a rule outside whatever
+   * the first draw happened to be. Returns `null` if no match turns up
+   * within the attempt budget or the matched page can't be parsed.
    */
   static async getRule(name) {
     if (!name || name.trim() === "")
       return null;
     const target = name.trim().toLocaleLowerCase("tr-TR");
-    for (let attempt = 0; attempt < 25; attempt++) {
-      const rules = await this.getKurallar();
-      const match = rules.find((r) => r.adi.toLocaleLowerCase("tr-TR").includes(target));
-      if (match)
-        return this.fetchRuleText(match.url);
-      await this.delay(100);
+    const BATCH_SIZE = 5;
+    const ROUNDS = 5;
+    for (let round = 0; round < ROUNDS; round++) {
+      const batches = await Promise.all(
+        Array.from({ length: BATCH_SIZE }, () => this.getKurallar(true))
+      );
+      for (const rules of batches) {
+        const match = rules.find((r) => r.adi.toLocaleLowerCase("tr-TR").includes(target));
+        if (match)
+          return this.fetchRuleText(match.url);
+      }
     }
     return null;
   }
@@ -673,6 +700,11 @@ var TDK = class {
    * Analyzes every distinct word in a text (Turkish stopwords filtered out),
    * returning each word's first meaning and etymological origin if found.
    * Looks each word up individually (throttled), so scales with text length.
+   * TDK only indexes dictionary (dictionary/root) forms, not inflected ones —
+   * it does no morphological analysis, and neither does this method: a
+   * suffixed word like "evde" or "dildir" (root "ev"/"dil" plus a case/verb
+   * suffix) will come back `found: false` even though the root is a real
+   * headword. This is an inherent limitation of the data source, not a bug.
    */
   static async analyzeText(text) {
     const words = text.toLocaleLowerCase("tr-TR").replace(/[^\p{L}\s]/gu, " ").split(/\s+/).filter((w) => w.length > 1 && !this.STOPWORDS.has(w));
@@ -692,9 +724,13 @@ var TDK = class {
     return analyses;
   }
   /**
-   * Classic edit-distance between two strings.
+   * Damerau-Levenshtein edit-distance (optimal string alignment variant):
+   * like classic Levenshtein but also counts an adjacent-character
+   * transposition (e.g. "yanlız" -> "yalnız") as a single edit instead of
+   * two substitutions — a very common class of typo that plain Levenshtein
+   * otherwise misses.
    */
-  static levenshtein(a, b) {
+  static damerauLevenshtein(a, b) {
     const dp = Array.from({ length: a.length + 1 }, () => new Array(b.length + 1).fill(0));
     for (let i = 0; i <= a.length; i++)
       dp[i][0] = i;
@@ -704,6 +740,9 @@ var TDK = class {
       for (let j = 1; j <= b.length; j++) {
         const cost = a[i - 1] === b[j - 1] ? 0 : 1;
         dp[i][j] = Math.min(dp[i - 1][j] + 1, dp[i][j - 1] + 1, dp[i - 1][j - 1] + cost);
+        if (i > 1 && j > 1 && a[i - 1] === b[j - 2] && a[i - 2] === b[j - 1]) {
+          dp[i][j] = Math.min(dp[i][j], dp[i - 2][j - 2] + cost);
+        }
       }
     }
     return dp[a.length][b.length];

package/dist/index.mjs

@@ -3,7 +3,7 @@ import {
   TDKError,
   TDKNetworkError,
   TDKValidationError
-} from "./chunk-2TA5PMVZ.mjs";
+} from "./chunk-SNY3KUCF.mjs";
 export {
   TDK,
   TDKError,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tdk-api-wrapper",
-  "version": "1.2.0",
+  "version": "1.2.2",
   "description": "TDK (Türk Dil Kurumu) unofficial live data API wrapper for Node.js",
   "main": "dist/index.js",
   "module": "dist/index.mjs",

package/src/tdk.ts

@@ -389,8 +389,10 @@ export class TDK {
     if (results.length > 0) {
       return { isCorrect: true, word };
     }
-    
-    // 2. If not, check "sıkça yapılan yanlışlar" from DailyContent
+
+    // 2. If not, check "sıkça yapılan yanlışlar" from DailyContent — an exact
+    // match here is TDK explicitly saying "X is often confused with Y", so
+    // it's authoritative when it hits (but only 2-3 rotating entries per call).
     const daily = await this.getDailyContent();
     if (daily) {
       const syydMatch = daily.syyd.find(s => s.yanliskelime.toLocaleLowerCase("tr-TR") === word.toLocaleLowerCase("tr-TR"));
@@ -401,43 +403,67 @@ export class TDK {
       if (mixMatch) {
         return { isCorrect: false, word, suggestion: mixMatch.dogru };
       }
+    }
 
-      // 3. No exact match in TDK's fixed lists: fall back to the closest word
-      // (by edit distance) within that same small pool. This is NOT a search
-      // over the full dictionary — TDK exposes no such lookup — just a
-      // best-effort nudge using the "sık yapılan yanlışlar" data we already have.
-      const candidates = [
-        ...daily.syyd.map((s) => s.dogrukelime),
-        ...daily.karistirma.flatMap((s) => [s.yanlis, s.dogru]),
-        ...daily.kelime.map((k) => k.madde),
-      ];
-      let best: { candidate: string; distance: number } | null = null;
-      for (const candidate of candidates) {
-        const distance = this.levenshtein(word.toLocaleLowerCase("tr-TR"), candidate.toLocaleLowerCase("tr-TR"));
-        if (distance > 0 && (!best || distance < best.distance)) {
-          best = { candidate, distance };
-        }
-      }
-      if (best && best.distance <= 2) {
-        return { isCorrect: false, word, suggestion: best.candidate };
+    // 3. No exact match in TDK's curated lists: fall back to the closest
+    // headword (by edit distance) across TDK's full ~81k-word list (the same
+    // data `getSuggestions()` uses). Restricted to single-token, lowercase
+    // headwords so it doesn't suggest compounds/phrases or proper nouns.
+    // Candidates whose length differs too much are skipped before running
+    // the O(n*m) distance calculation, both for speed and because a huge
+    // length gap can't be within the distance threshold anyway. Ties (same
+    // distance) prefer a matching first letter, then a matching length —
+    // typos rarely change the first letter, and this avoids picking
+    // whatever happens to sort alphabetically first. There's no word
+    // frequency data available, so a genuine tie can still land on a
+    // technically-correct but less commonly intended word.
+    if (this.autocompleteCache.length === 0) {
+      this.autocompleteCache = await this.fetchAutocompleteData();
+    }
+    const cleanWord = word.trim().toLocaleLowerCase("tr-TR");
+    let best: { candidate: string; distance: number; firstMismatch: number; lengthMismatch: number } | null = null;
+    for (const candidate of this.autocompleteCache) {
+      if (candidate.includes(" ") || candidate !== candidate.toLocaleLowerCase("tr-TR")) continue;
+      if (Math.abs(candidate.length - cleanWord.length) > 2) continue;
+
+      const distance = this.damerauLevenshtein(cleanWord, candidate);
+      if (distance === 0) continue;
+
+      const firstMismatch = candidate[0] === cleanWord[0] ? 0 : 1;
+      const lengthMismatch = candidate.length === cleanWord.length ? 0 : 1;
+      const better =
+        !best ||
+        distance < best.distance ||
+        (distance === best.distance && firstMismatch < best.firstMismatch) ||
+        (distance === best.distance && firstMismatch === best.firstMismatch && lengthMismatch < best.lengthMismatch);
+      if (better) {
+        best = { candidate, distance, firstMismatch, lengthMismatch };
       }
     }
+    if (best && best.distance <= 2) {
+      return { isCorrect: false, word, suggestion: best.candidate };
+    }
     return { isCorrect: false, word };
   }
 
   /**
    * Fetches daily content (word of the day, proverbs, rules, etc).
+   * `bypassCache` skips both reading and writing `dailyContentCache` even
+   * when `enableCache(true)` is on — used by `getRule()`'s retry loop, which
+   * needs a fresh random `/icerik` draw on every attempt; without it, once
+   * caching is enabled the loop would just re-read the same cached response
+   * 25 times and could never find a rule outside that first random draw.
    */
-  public static async getDailyContent(): Promise<DailyContent | null> {
-    if (this.isCacheEnabled && this.dailyContentCache) return this.dailyContentCache;
-    
+  public static async getDailyContent(bypassCache = false): Promise<DailyContent | null> {
+    if (!bypassCache && this.isCacheEnabled && this.dailyContentCache) return this.dailyContentCache;
+
     try {
       const response = await fetch(`${this.BASE_URL}/icerik`, {
         headers: { "User-Agent": "TDK-API-Nodejs-Wrapper/1.0" },
       });
       if (response.ok) {
         const data = await response.json() as DailyContent;
-        if (this.isCacheEnabled) this.dailyContentCache = data;
+        if (!bypassCache && this.isCacheEnabled) this.dailyContentCache = data;
         return data;
       }
     } catch {
@@ -480,10 +506,12 @@ export class TDK {
    * `/icerik` daily-content feed, e.g. `{ adi: "Kısaltmalar", url: "https://..." }`.
    * Note: like `getRandomWord()`, this is NOT a fixed catalog — `/icerik`
    * appears to hand back a single randomly-rotated rule per request, so two
-   * calls a second apart can return entirely different rules.
+   * calls a second apart can return entirely different rules. `bypassCache`
+   * (used internally by `getRule()`'s retry loop) forces a fresh `/icerik`
+   * draw even when `enableCache(true)` is on.
    */
-  public static async getKurallar(): Promise<TDKRule[]> {
-    const daily = await this.getDailyContent();
+  public static async getKurallar(bypassCache = false): Promise<TDKRule[]> {
+    const daily = await this.getDailyContent(bypassCache);
     return daily?.kural ?? [];
   }
 
@@ -492,20 +520,32 @@ export class TDK {
    * case-insensitively, substring match) from `tdk.gov.tr`. Since `/icerik`
    * hands back a single randomly-rotated rule per request (out of a pool of
    * roughly twenty) rather than a fixed catalog, a single `getKurallar()`
-   * draw would rarely match a given name — this re-draws (bounded, with a
-   * short delay) until it finds a match or gives up. Returns `null` if no
-   * match turns up within the attempt budget or the matched page can't be
-   * parsed.
+   * draw would rarely match a given name — this re-draws until it finds a
+   * match or gives up. Draws happen in concurrent batches (each `/icerik`
+   * request is independent and stateless) rather than one-at-a-time with a
+   * delay: same total sample size (25) and hit probability as a sequential
+   * loop, but bounded to a handful of round-trips instead of 25 of them, so
+   * a miss resolves in roughly one round-trip time instead of several
+   * seconds. Every draw bypasses `dailyContentCache` — without that, once
+   * `enableCache(true)` is on, every attempt would just re-read the same
+   * cached `/icerik` response and could never find a rule outside whatever
+   * the first draw happened to be. Returns `null` if no match turns up
+   * within the attempt budget or the matched page can't be parsed.
    */
   public static async getRule(name: string): Promise<string | null> {
     if (!name || name.trim() === "") return null;
     const target = name.trim().toLocaleLowerCase("tr-TR");
 
-    for (let attempt = 0; attempt < 25; attempt++) {
-      const rules = await this.getKurallar();
-      const match = rules.find((r) => r.adi.toLocaleLowerCase("tr-TR").includes(target));
-      if (match) return this.fetchRuleText(match.url);
-      await this.delay(100);
+    const BATCH_SIZE = 5;
+    const ROUNDS = 5;
+    for (let round = 0; round < ROUNDS; round++) {
+      const batches = await Promise.all(
+        Array.from({ length: BATCH_SIZE }, () => this.getKurallar(true))
+      );
+      for (const rules of batches) {
+        const match = rules.find((r) => r.adi.toLocaleLowerCase("tr-TR").includes(target));
+        if (match) return this.fetchRuleText(match.url);
+      }
     }
     return null;
   }
@@ -641,6 +681,11 @@ export class TDK {
    * Analyzes every distinct word in a text (Turkish stopwords filtered out),
    * returning each word's first meaning and etymological origin if found.
    * Looks each word up individually (throttled), so scales with text length.
+   * TDK only indexes dictionary (dictionary/root) forms, not inflected ones —
+   * it does no morphological analysis, and neither does this method: a
+   * suffixed word like "evde" or "dildir" (root "ev"/"dil" plus a case/verb
+   * suffix) will come back `found: false` even though the root is a real
+   * headword. This is an inherent limitation of the data source, not a bug.
    */
   public static async analyzeText(text: string): Promise<WordAnalysis[]> {
     const words = text
@@ -666,9 +711,13 @@ export class TDK {
   }
 
   /**
-   * Classic edit-distance between two strings.
+   * Damerau-Levenshtein edit-distance (optimal string alignment variant):
+   * like classic Levenshtein but also counts an adjacent-character
+   * transposition (e.g. "yanlız" -> "yalnız") as a single edit instead of
+   * two substitutions — a very common class of typo that plain Levenshtein
+   * otherwise misses.
    */
-  private static levenshtein(a: string, b: string): number {
+  private static damerauLevenshtein(a: string, b: string): number {
     const dp: number[][] = Array.from({ length: a.length + 1 }, () => new Array(b.length + 1).fill(0));
     for (let i = 0; i <= a.length; i++) dp[i][0] = i;
     for (let j = 0; j <= b.length; j++) dp[0][j] = j;
@@ -676,6 +725,9 @@ export class TDK {
       for (let j = 1; j <= b.length; j++) {
         const cost = a[i - 1] === b[j - 1] ? 0 : 1;
         dp[i][j] = Math.min(dp[i - 1][j] + 1, dp[i][j - 1] + 1, dp[i - 1][j - 1] + cost);
+        if (i > 1 && j > 1 && a[i - 1] === b[j - 2] && a[i - 2] === b[j - 1]) {
+          dp[i][j] = Math.min(dp[i][j], dp[i - 2][j - 2] + cost);
+        }
       }
     }
     return dp[a.length][b.length];