tdk-api-wrapper 1.0.1 → 1.1.0

package/dist/cli.mjs

@@ -1,79 +1,250 @@
 #!/usr/bin/env node
 import {
   TDK
-} from "./chunk-MGSXCUAX.mjs";
+} from "./chunk-P3GX7I53.mjs";
 
 // src/cli.ts
-var args = process.argv.slice(2);
+var rawArgs = process.argv.slice(2);
+var jsonMode = rawArgs.includes("--json");
+var args = rawArgs.filter((a) => a !== "--json");
+var KNOWN_COMMANDS = /* @__PURE__ */ new Set([
+  "ara",
+  "anlam",
+  "koken",
+  "ornek",
+  "hece",
+  "uyum",
+  "yazim",
+  "gunun",
+  "rastgele",
+  "esanlam",
+  "karsit",
+  "yabanci",
+  "kurallar",
+  "kural",
+  "karsilastir",
+  "analiz"
+]);
 var command = args[0];
-var word = args[1];
+var word = args.slice(1).join(" ");
+if (command && !KNOWN_COMMANDS.has(command) && command !== "--help" && command !== "-h") {
+  word = args.join(" ");
+  command = "anlam";
+}
+function printResult(data, formatted) {
+  if (jsonMode) {
+    console.log(JSON.stringify(data));
+  } else {
+    formatted();
+  }
+}
+function printError(message) {
+  if (jsonMode) {
+    console.log(JSON.stringify({ error: message }));
+  } else {
+    console.log(`Hata: ${message}`);
+  }
+}
 async function run() {
-  if (!command) {
-    console.log("Kullan\u0131m: tdk <komut> <kelime>");
-    console.log("Komutlar: ara, anlam, koken, ornek, hece, uyum, yazim");
-    process.exit(1);
+  if (!command || command === "--help" || command === "-h") {
+    console.log("Kullan\u0131m: tdk [komut] <kelime> [--json]");
+    console.log(
+      "Komutlar: ara, anlam, koken, ornek, hece, uyum, yazim, gunun, rastgele, esanlam, karsit, yabanci, kurallar, kural, karsilastir, analiz"
+    );
+    console.log("Not: Komut belirtilmezse do\u011Frudan kelime anlam\u0131 aran\u0131r (\xF6rn: tdk selam)");
+    process.exit(command ? 0 : 1);
   }
   TDK.enableCache(false);
   try {
     switch (command) {
       case "ara":
-      case "anlam":
+      case "anlam": {
         if (!word)
           throw new Error("Kelime belirtmelisiniz.");
         const meanings = await TDK.getMeanings(word);
-        if (meanings.length === 0) {
-          console.log("Sonu\xE7 bulunamad\u0131.");
-        } else {
-          meanings.forEach((m, i) => console.log(`${i + 1}. ${m}`));
-        }
+        printResult(meanings, () => {
+          if (meanings.length === 0) {
+            console.log("Sonu\xE7 bulunamad\u0131.");
+          } else {
+            meanings.forEach((m, i) => console.log(`${i + 1}. ${m}`));
+          }
+        });
         break;
-      case "koken":
+      }
+      case "koken": {
         if (!word)
           throw new Error("Kelime belirtmelisiniz.");
         const origin = await TDK.getOrigin(word);
-        console.log(`K\xF6ken: ${origin}`);
+        printResult({ word, origin }, () => console.log(`K\xF6ken: ${origin}`));
         break;
-      case "ornek":
+      }
+      case "ornek": {
         if (!word)
           throw new Error("Kelime belirtmelisiniz.");
         const examples = await TDK.getExamples(word);
-        if (examples.length === 0) {
-          console.log("\xD6rnek bulunamad\u0131.");
-        } else {
-          examples.forEach((ex, i) => {
-            const yazar = ex.author ? ` (${ex.author})` : "";
-            console.log(`${i + 1}. ${ex.sentence}${yazar}`);
-          });
-        }
+        printResult(examples, () => {
+          if (examples.length === 0) {
+            console.log("\xD6rnek bulunamad\u0131.");
+          } else {
+            examples.forEach((ex, i) => {
+              const yazar = ex.author ? ` (${ex.author})` : "";
+              console.log(`${i + 1}. ${ex.sentence}${yazar}`);
+            });
+          }
+        });
         break;
-      case "hece":
+      }
+      case "hece": {
         if (!word)
           throw new Error("Kelime belirtmelisiniz.");
         const syllables = TDK.syllabicate(word);
-        console.log(`Heceler: ${syllables.join("-")}`);
+        printResult(syllables, () => console.log(`Heceler: ${syllables.join("-")}`));
         break;
-      case "uyum":
+      }
+      case "uyum": {
         if (!word)
           throw new Error("Kelime belirtmelisiniz.");
         const isHarmony = TDK.checkVowelHarmony(word);
-        console.log(`B\xFCy\xFCk \xDCnl\xFC Uyumu: ${isHarmony ? "Uyar" : "Uymaz"}`);
+        printResult(
+          { word, harmony: isHarmony },
+          () => console.log(`B\xFCy\xFCk \xDCnl\xFC Uyumu: ${isHarmony ? "Uyar" : "Uymaz"}`)
+        );
         break;
-      case "yazim":
+      }
+      case "yazim": {
         if (!word)
           throw new Error("Kelime belirtmelisiniz.");
         const spellResult = await TDK.checkSpelling(word);
-        if (spellResult.isCorrect) {
-          console.log("Do\u011Fru yaz\u0131m.");
-        } else {
-          console.log(`Yanl\u0131\u015F yaz\u0131m.${spellResult.suggestion ? " Do\u011Frusu: " + spellResult.suggestion : ""}`);
-        }
+        printResult(spellResult, () => {
+          if (spellResult.isCorrect) {
+            console.log("Do\u011Fru yaz\u0131m.");
+          } else {
+            console.log(`Yanl\u0131\u015F yaz\u0131m.${spellResult.suggestion ? " Do\u011Frusu: " + spellResult.suggestion : ""}`);
+          }
+        });
+        break;
+      }
+      case "gunun": {
+        const wotd = await TDK.getWordOfTheDay();
+        printResult(wotd, () => {
+          if (!wotd) {
+            console.log("G\xFCn\xFCn kelimesi al\u0131namad\u0131.");
+          } else {
+            console.log(`G\xFCn\xFCn kelimesi: ${wotd.word}`);
+            wotd.meanings.forEach((m, i) => console.log(`${i + 1}. ${m}`));
+          }
+        });
+        break;
+      }
+      case "rastgele": {
+        const pick = await TDK.getRandomWord();
+        printResult(pick, () => {
+          if (!pick) {
+            console.log("Rastgele i\xE7erik al\u0131namad\u0131.");
+          } else {
+            const label = pick.type === "kelime" ? "Kelime" : "Atas\xF6z\xFC";
+            console.log(`${label}: ${pick.madde}`);
+            console.log(pick.anlam);
+          }
+        });
+        break;
+      }
+      case "esanlam": {
+        if (!word)
+          throw new Error("Kelime belirtmelisiniz.");
+        const synonyms = await TDK.getSynonyms(word);
+        printResult(synonyms, () => {
+          if (synonyms.length === 0) {
+            console.log("E\u015F anlaml\u0131 kelime bulunamad\u0131.");
+          } else {
+            synonyms.forEach((s, i) => console.log(`${i + 1}. ${s}`));
+          }
+        });
+        break;
+      }
+      case "karsit": {
+        if (!word)
+          throw new Error("Kelime belirtmelisiniz.");
+        const antonyms = await TDK.getAntonyms(word);
+        printResult(antonyms, () => {
+          if (antonyms.length === 0) {
+            console.log("Z\u0131t anlaml\u0131 kelime bulunamad\u0131.");
+          } else {
+            antonyms.forEach((s, i) => console.log(`${i + 1}. ${s}`));
+          }
+        });
+        break;
+      }
+      case "yabanci": {
+        if (!word)
+          throw new Error("Kelime belirtmelisiniz.");
+        const foreign = await TDK.isForeignWord(word);
+        printResult({ word, foreign }, () => {
+          if (foreign === null) {
+            console.log("Kelime bulunamad\u0131.");
+          } else {
+            console.log(foreign ? "Yabanc\u0131 k\xF6kenli." : "T\xFCrk\xE7e k\xF6kenli.");
+          }
+        });
+        break;
+      }
+      case "kurallar": {
+        const rules = await TDK.getKurallar();
+        printResult(rules, () => {
+          if (rules.length === 0) {
+            console.log("Kural listesi al\u0131namad\u0131.");
+          } else {
+            rules.forEach((r, i) => console.log(`${i + 1}. ${r.adi}`));
+          }
+        });
+        break;
+      }
+      case "kural": {
+        if (!word)
+          throw new Error("Kural ad\u0131 belirtmelisiniz.");
+        const rule = await TDK.getRule(word);
+        printResult(rule, () => {
+          console.log(rule ?? "Kural bulunamad\u0131.");
+        });
+        break;
+      }
+      case "karsilastir": {
+        const [wordA, wordB] = args.slice(1);
+        if (!wordA || !wordB)
+          throw new Error("\u0130ki kelime belirtmelisiniz.");
+        const comparison = await TDK.compareWords(wordA, wordB);
+        printResult(comparison, () => {
+          for (const side of [comparison.a, comparison.b]) {
+            console.log(`${side.word}: ${side.meaningCount} anlam, k\xF6ken: ${side.origin ?? "bulunamad\u0131"}, hece: ${side.syllables.join("-")}, b\xFCy\xFCk \xFCnl\xFC uyumu: ${side.harmony ? "uyar" : "uymaz"}`);
+          }
+        });
+        break;
+      }
+      case "analiz": {
+        if (!word)
+          throw new Error("Metin belirtmelisiniz.");
+        const analysis = await TDK.analyzeText(word);
+        printResult(analysis, () => {
+          if (analysis.length === 0) {
+            console.log("Analiz edilecek kelime bulunamad\u0131.");
+          } else {
+            analysis.forEach((a) => {
+              if (a.found) {
+                console.log(`${a.word}: ${a.meaning ?? "-"} (${a.origin})`);
+              } else {
+                console.log(`${a.word}: bulunamad\u0131`);
+              }
+            });
+          }
+        });
         break;
+      }
       default:
-        console.log("Bilinmeyen komut.");
+        printError("Bilinmeyen komut.");
     }
   } catch (error) {
     if (error instanceof Error) {
-      console.log(`Hata: ${error.message}`);
+      printError(error.message);
     }
   }
 }

package/dist/index.d.mts

@@ -96,6 +96,36 @@ interface SpellCheckResult {
     word: string;
     suggestion?: string;
 }
+interface WordOfTheDay {
+    word: string;
+    meanings: string[];
+}
+interface DailyPick {
+    type: "kelime" | "atasoz";
+    madde: string;
+    anlam: string;
+}
+interface TDKRule {
+    adi: string;
+    url: string;
+}
+interface WordComparisonSide {
+    word: string;
+    meaningCount: number;
+    origin: string | null;
+    syllables: string[];
+    harmony: boolean;
+}
+interface WordComparison {
+    a: WordComparisonSide;
+    b: WordComparisonSide;
+}
+interface WordAnalysis {
+    word: string;
+    found: boolean;
+    meaning: string | null;
+    origin: string | null;
+}
 type TDKResponse = WordInfo[] | {
     error: string;
 };
@@ -105,6 +135,7 @@ type TDKResponse = WordInfo[] | {
  */
 declare class TDK {
     private static readonly BASE_URL;
+    private static readonly AUDIO_API_HOST;
     private static isCacheEnabled;
     private static wordCache;
     private static dailyContentCache;
@@ -135,9 +166,21 @@ declare class TDK {
      */
     static getProverbs(word: string): Promise<string[]>;
     /**
-     * Returns the etymological origin of the word if it's a foreign word.
+     * Returns the etymological origin of the word, or "Türkçe" if TDK doesn't
+     * record a foreign origin for it. Returns `null` only when the word itself
+     * isn't found in the dictionary at all.
      */
     static getOrigin(word: string): Promise<string | null>;
+    /**
+     * Returns whether the word has a recorded foreign etymological origin.
+     * Returns `null` (instead of a boolean) when the word isn't found at all.
+     */
+    static isForeignWord(word: string): Promise<boolean | null>;
+    /**
+     * Groups a list of words by their etymological origin. Words not found in
+     * the dictionary are grouped under "Bilinmiyor". Throttled like getWordsBatch.
+     */
+    static groupByOrigin(words: string[]): Promise<Record<string, string[]>>;
     /**
      * Returns literature examples containing the word.
      */
@@ -146,8 +189,34 @@ declare class TDK {
         author: string | null;
     }[]>;
     /**
-     * Returns the direct URL of the audio pronunciation if available.
-     * Note: TDK audio URL usually uses the exact audio id. Sometimes it requires MD5, but we provide a common pattern.
+     * Calls the `api.sozluk.gov.tr/gts-yeni` endpoint the official web UI uses
+     * internally (richer than the public `/gts`: includes `seskod`,
+     * `anlamEsAnlam`/`anlamKarsitAnlam`, etc). That endpoint 403s unless the
+     * request looks like it came from a browser tab on sozluk.gov.tr: it needs
+     * an `Origin`/`Referer` pair matching that site AND a browser-like
+     * `User-Agent` (our usual `TDK-API-Nodejs-Wrapper/…` UA gets rejected).
+     * `fetch` (undici) also strips a manually-set `Origin` header as a
+     * forbidden header name, so this uses `node:https` directly instead.
+     * This is inherently fragile scraping of an undocumented endpoint — if
+     * TDK tightens this check further, this should fail closed to `null`
+     * rather than throw.
+     */
+    private static fetchGtsYeni;
+    private static fetchSeskod;
+    /**
+     * Returns synonyms ("eş anlamlı kelimeler") recorded for the word, pooled
+     * across all of its meanings. Uses the same undocumented `gts-yeni`
+     * endpoint as `getAudioUrl` — returns `[]` if the lookup fails.
+     */
+    static getSynonyms(word: string): Promise<string[]>;
+    /**
+     * Returns antonyms ("zıt anlamlı kelimeler") recorded for the word, pooled
+     * across all of its meanings. Uses the same undocumented `gts-yeni`
+     * endpoint as `getAudioUrl` — returns `[]` if the lookup fails.
+     */
+    static getAntonyms(word: string): Promise<string[]>;
+    /**
+     * Returns the direct URL of the audio pronunciation, if TDK has one recorded for this word.
      */
     static getAudioUrl(word: string): Promise<string | null>;
     /**
@@ -162,14 +231,70 @@ declare class TDK {
      * Fetches daily content (word of the day, proverbs, rules, etc).
      */
     static getDailyContent(): Promise<DailyContent | null>;
+    /**
+     * Returns today's word of the day along with all of its listed meanings.
+     */
+    static getWordOfTheDay(): Promise<WordOfTheDay | null>;
+    /**
+     * Picks a random entry (word or proverb) from today's daily content.
+     * Note: this samples from today's `getDailyContent()` picks, not the full dictionary.
+     */
+    static getRandomWord(): Promise<DailyPick | null>;
+    /**
+     * Returns the spelling-rule page(s) ("yazım kuralları") linked from TDK's
+     * `/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.
+     */
+    static getKurallar(): 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.
+     */
+    static getRule(name: string): Promise<string | null>;
+    /**
+     * `tdk.gov.tr` rule pages are WordPress/Avada-themed. The actual article
+     * text lives in `<div ... itemprop="text">...</div>` right before a
+     * `<footer class="entry...">` (share buttons, author box, structured-data
+     * spans) — cutting there avoids that trailing cruft.
+     */
+    private static fetchRuleText;
+    private static htmlToPlainText;
     /**
      * Returns compound words that contain this word.
      */
     static getCompoundWords(word: string): Promise<string[]>;
     /**
      * Returns the part of speech (isim, sıfat, zarf vb.).
+     * TDK's `ozelliklerListe` mixes grammatical categories (`tur: "3"`, e.g.
+     * sıfat/zarf/isim) with usage-register tags (`tur: "4"`, e.g. mecaz/argo)
+     * in the same list — only `tur === "3"` entries are actual parts of speech.
      */
     static getPartOfSpeech(word: string): Promise<string[]>;
+    /**
+     * Compares two words side by side: meaning count, etymological origin,
+     * syllables and vowel-harmony compliance.
+     */
+    static compareWords(a: string, b: string): Promise<WordComparison>;
+    private static readonly STOPWORDS;
+    private static firstMeaning;
+    /**
+     * 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.
+     */
+    static analyzeText(text: string): Promise<WordAnalysis[]>;
+    /**
+     * Classic edit-distance between two strings.
+     */
+    private static levenshtein;
     /**
      * Fetches multiple words concurrently with a small delay to avoid rate limiting.
      */
@@ -180,8 +305,36 @@ declare class TDK {
     static syllabicate(word: string): string[];
     /**
      * Checks if a word follows Turkish Major Vowel Harmony (Büyük Ünlü Uyumu).
+     * Normalizes case via the Turkish locale first: a plain case-insensitive
+     * regex would fold ASCII "I" to "i", misreading the back vowel "I"
+     * (dotless) as the front vowel "i" (dotted).
      */
     static checkVowelHarmony(word: string): boolean;
 }
 
-export { type Author, type DailyContent, type Example, type Feature, type Meaning, type Proverb, type SpellCheckResult, TDK, type TDKResponse, type WordInfo };
+/**
+ * Base class for all errors thrown by this library.
+ */
+declare class TDKError extends Error {
+    constructor(message: string);
+}
+/**
+ * Thrown when a caller-supplied argument is invalid (e.g. an empty word).
+ */
+declare class TDKValidationError extends TDKError {
+    constructor(message: string);
+}
+/**
+ * Thrown when a request to sozluk.gov.tr fails at the network/HTTP level
+ * (connection failure, non-OK HTTP status, unparsable response, etc).
+ */
+declare class TDKNetworkError extends TDKError {
+    readonly status?: number;
+    readonly cause?: unknown;
+    constructor(message: string, options?: {
+        status?: number;
+        cause?: unknown;
+    });
+}
+
+export { type Author, type DailyContent, type DailyPick, type Example, type Feature, type Meaning, type Proverb, type SpellCheckResult, TDK, TDKError, TDKNetworkError, type TDKResponse, type TDKRule, TDKValidationError, type WordAnalysis, type WordComparison, type WordComparisonSide, type WordInfo, type WordOfTheDay };