tdk-api-wrapper 1.3.1 → 1.5.0

package/src/types.ts

@@ -85,6 +85,15 @@ export interface SpellCheckResult {
   isCorrect: boolean;
   word: string;
   suggestion?: string;
+  isInflected?: boolean;
+  root?: string;
+}
+
+export interface StemResult {
+  word: string;
+  root: string;
+  isInflected: boolean;
+  candidates?: string[];
 }
 
 export interface WordOfTheDay {
@@ -109,6 +118,7 @@ export interface WordComparisonSide {
   origin: string | null;
   syllables: string[];
   harmony: boolean;
+  labialHarmony?: boolean;
 }
 
 export interface WordComparison {
@@ -121,6 +131,44 @@ export interface WordAnalysis {
   found: boolean;
   meaning: string | null;
   origin: string | null;
+  root?: string;
+  isInflected?: boolean;
+}
+
+export interface ProofreadIssue {
+  type: "spelling" | "conjunction_da" | "conjunction_ki" | "question_particle";
+  word: string;
+  startIndex: number;
+  endIndex: number;
+  suggestion?: string;
+  message: string;
+}
+
+export interface ProofreadResult {
+  text: string;
+  issues: ProofreadIssue[];
+  isCorrect: boolean;
+}
+
+export interface PatternSearchOptions {
+  maxResults?: number;
+}
+
+export interface AnagramOptions {
+  exactLength?: boolean;
+  maxResults?: number;
+}
+
+export interface RhymeOptions {
+  minLetters?: number;
+  maxResults?: number;
+}
+
+export interface TDKConfig {
+  timeoutMs?: number;
+  retries?: number;
+  cache?: boolean;
+  maxCacheSize?: number;
 }
 
 export interface KubbealtiEntry {
@@ -134,3 +182,4 @@ export interface WiktionaryEntry {
 }
 
 export type TDKResponse = WordInfo[] | { error: string };
+

package/test/grammar.test.js

@@ -0,0 +1,52 @@
+const assert = require("node:assert");
+const { TDK } = require("../dist/index.js");
+
+async function runTests() {
+  console.log("=== Running Grammar & Phonology Unit Tests ===");
+
+  // 1. Büyük Ünlü Uyumu (Major Vowel Harmony)
+  console.log("1. Testing checkVowelHarmony (Büyük Ünlü Uyumu)...");
+  assert.strictEqual(TDK.checkVowelHarmony("adım"), true);
+  assert.strictEqual(TDK.checkVowelHarmony("kapı"), true);
+  assert.strictEqual(TDK.checkVowelHarmony("gözlük"), true);
+  assert.strictEqual(TDK.checkVowelHarmony("otobüs"), false);
+  assert.strictEqual(TDK.checkVowelHarmony("kalem"), false);
+  assert.strictEqual(TDK.checkVowelHarmony("kitap"), false);
+  assert.strictEqual(TDK.checkVowelHarmony("ev"), true);
+  console.log("  ✓ checkVowelHarmony passed.");
+
+  // 2. Küçük Ünlü Uyumu (Minor Vowel / Labial Harmony)
+  console.log("2. Testing checkLabialHarmony (Küçük Ünlü Uyumu)...");
+  assert.strictEqual(TDK.checkLabialHarmony("elma"), true);
+  assert.strictEqual(TDK.checkLabialHarmony("kalem"), true);
+  assert.strictEqual(TDK.checkLabialHarmony("odun"), true);
+  assert.strictEqual(TDK.checkLabialHarmony("kömür"), true);
+  assert.strictEqual(TDK.checkLabialHarmony("çocuk"), true);
+  assert.strictEqual(TDK.checkLabialHarmony("armut"), false);
+  assert.strictEqual(TDK.checkLabialHarmony("yağmur"), false);
+  assert.strictEqual(TDK.checkLabialHarmony("tavuk"), false);
+  assert.strictEqual(TDK.checkLabialHarmony("doktor"), false);
+  assert.strictEqual(TDK.checkLabialHarmony("horoz"), false);
+  assert.strictEqual(TDK.checkLabialHarmony("müzik"), false);
+  assert.strictEqual(TDK.checkLabialHarmony("ev"), true);
+  console.log("  ✓ checkLabialHarmony passed.");
+
+  // 3. Heceleme (Syllabification)
+  console.log("3. Testing syllabicate...");
+  assert.deepStrictEqual(TDK.syllabicate("kalem"), ["ka", "lem"]);
+  assert.deepStrictEqual(TDK.syllabicate("ilkokul"), ["il", "ko", "kul"]);
+  assert.deepStrictEqual(TDK.syllabicate("muvaffakiyet"), ["mu", "vaf", "fa", "ki", "yet"]);
+  assert.deepStrictEqual(TDK.syllabicate("elektrik"), ["e", "lek", "trik"]);
+  assert.deepStrictEqual(TDK.syllabicate("kontrol"), ["kon", "trol"]);
+  assert.deepStrictEqual(TDK.syllabicate("orkestra"), ["or", "kes", "tra"]);
+  assert.deepStrictEqual(TDK.syllabicate("kral"), ["kral"]);
+  assert.deepStrictEqual(TDK.syllabicate("tren"), ["tren"]);
+  console.log("  ✓ syllabicate passed.");
+
+  console.log("\n All grammar & phonology tests passed successfully!");
+}
+
+runTests().catch((err) => {
+  console.error("Test failed:", err);
+  process.exit(1);
+});

package/test/morphology.test.js

@@ -0,0 +1,129 @@
+const assert = require("node:assert");
+const {
+  TDK,
+  getStemCandidates,
+  restoreConsonantSoftening,
+  restoreVowelDrop,
+  restoreInfinitive,
+  restoreGemination,
+  restoreVowelNarrowing,
+} = require("../dist/index.js");
+
+async function runTests() {
+  console.log("=== Running Morphology Unit & Integration Tests ===");
+
+  // 1. Phonology helpers
+  console.log("1. Testing phonology helper functions...");
+  assert.deepStrictEqual(restoreConsonantSoftening("kitab"), ["kitap"]);
+  assert.deepStrictEqual(restoreConsonantSoftening("çocuğ"), ["çocuk"]);
+  assert.deepStrictEqual(restoreConsonantSoftening("ağac"), ["ağaç"]);
+  assert.deepStrictEqual(restoreConsonantSoftening("kanad"), ["kanat"]);
+  assert.deepStrictEqual(restoreConsonantSoftening("reng"), ["renk"]);
+  assert.deepStrictEqual(restoreVowelDrop("akl"), ["akıl"]);
+  assert.deepStrictEqual(restoreVowelDrop("şehr"), ["şehir"]);
+  assert.deepStrictEqual(restoreVowelDrop("omz"), ["omuz"]);
+  assert.deepStrictEqual(restoreInfinitive("oku"), ["okumak"]);
+  assert.deepStrictEqual(restoreInfinitive("gel"), ["gelmek"]);
+  assert.deepStrictEqual(restoreGemination("hakk"), ["hak"]);
+  assert.deepStrictEqual(restoreGemination("hiss"), ["his"]);
+  assert.deepStrictEqual(restoreGemination("redd"), ["red", "ret"]);
+  assert.deepStrictEqual(restoreGemination("aff"), ["af"]);
+  assert.deepStrictEqual(restoreVowelNarrowing("başlı"), ["başla"]);
+  assert.deepStrictEqual(restoreVowelNarrowing("bekli"), ["bekle"]);
+  assert.deepStrictEqual(restoreVowelNarrowing("di"), ["de"]);
+  assert.deepStrictEqual(restoreVowelNarrowing("yi"), ["ye"]);
+  console.log("  ✓ Phonology helpers passed.");
+
+  // 2. Candidate generation
+  console.log("2. Testing getStemCandidates...");
+  const c1 = getStemCandidates("halılarımızın");
+  assert(c1.includes("halı"), "halılarımızın must contain halı");
+
+  const c2 = getStemCandidates("kitabımız");
+  assert(c2.includes("kitap"), "kitabımız must contain kitap");
+
+  const c3 = getStemCandidates("çocuğa");
+  assert(c3.includes("çocuk"), "çocuğa must contain çocuk");
+
+  const c4 = getStemCandidates("şehre");
+  assert(c4.includes("şehir"), "şehre must contain şehir");
+
+  const c5 = getStemCandidates("aklımızda");
+  assert(c5.includes("akıl"), "aklımızda must contain akıl");
+
+  const c6 = getStemCandidates("okuyoruz");
+  assert(c6.includes("okumak"), "okuyoruz must contain okumak");
+
+  const c7 = getStemCandidates("gideceğiz");
+  assert(c7.includes("gitmek"), "gideceğiz must contain gitmek");
+
+  const c8 = getStemCandidates("İstanbul'da");
+  assert(c8.includes("istanbul"), "İstanbul'da must contain istanbul");
+  console.log("  ✓ Candidate generation passed.");
+
+  // 3. TDK.isHeadword
+  console.log("3. Testing TDK.isHeadword...");
+  assert.strictEqual(await TDK.isHeadword("halı"), true);
+  assert.strictEqual(await TDK.isHeadword("kitap"), true);
+  assert.strictEqual(await TDK.isHeadword("okumak"), true);
+  assert.strictEqual(await TDK.isHeadword("gelmek"), true);
+  assert.strictEqual(await TDK.isHeadword("asdfqwertyzzz"), false);
+  console.log("  ✓ TDK.isHeadword passed.");
+
+  // 4. TDK.findRoot
+  console.log("4. Testing TDK.findRoot...");
+  assert.strictEqual(await TDK.findRoot("halılarımızın"), "halı");
+  assert.strictEqual(await TDK.findRoot("kitabımız"), "kitap");
+  assert.strictEqual(await TDK.findRoot("okuyoruz"), "okumak");
+  assert.strictEqual(await TDK.findRoot("çocukların"), "çocuk");
+  assert.strictEqual(await TDK.findRoot("kitap"), "kitap");
+  assert.strictEqual(await TDK.findRoot("hakkımızda"), "hak");
+  assert.strictEqual(await TDK.findRoot("başlıyor"), "başlamak");
+  assert.strictEqual(await TDK.findRoot("diyor"), "demek");
+  console.log("  ✓ TDK.findRoot passed.");
+
+  // 5. TDK.stem
+  console.log("5. Testing TDK.stem...");
+  const stem1 = await TDK.stem("halılarımızın");
+  assert(stem1 !== null);
+  assert.strictEqual(stem1.root, "halı");
+  assert.strictEqual(stem1.isInflected, true);
+
+  const stem2 = await TDK.stem("kitap");
+  assert(stem2 !== null);
+  assert.strictEqual(stem2.root, "kitap");
+  assert.strictEqual(stem2.isInflected, false);
+
+  const stem3 = await TDK.stem("hakkımızda");
+  assert(stem3 !== null);
+  assert.strictEqual(stem3.root, "hak");
+  assert.strictEqual(stem3.isInflected, true);
+  console.log("  ✓ TDK.stem passed.");
+
+  // 6. TDK.checkSpelling with morphology fallback
+  console.log("6. Testing TDK.checkSpelling with morphology fallback...");
+  const sp1 = await TDK.checkSpelling("halılarımızın");
+  assert.strictEqual(sp1.isCorrect, true);
+  assert.strictEqual(sp1.isInflected, true);
+  assert.strictEqual(sp1.root, "halı");
+
+  const sp2 = await TDK.checkSpelling("kitabımız");
+  assert.strictEqual(sp2.isCorrect, true);
+  assert.strictEqual(sp2.isInflected, true);
+  assert.strictEqual(sp2.root, "kitap");
+
+  const sp3 = await TDK.checkSpelling("yanlız");
+  assert.strictEqual(sp3.isCorrect, false);
+  assert.strictEqual(sp3.suggestion, "yalnız");
+
+  const sp4 = await TDK.checkSpelling("asdfxyz12345");
+  assert.strictEqual(sp4.isCorrect, false);
+  console.log("  ✓ TDK.checkSpelling passed.");
+
+  console.log("\n All morphology tests passed successfully!");
+}
+
+runTests().catch((err) => {
+  console.error("Test failed:", err);
+  process.exit(1);
+});

package/test/proofread.test.js

@@ -0,0 +1,60 @@
+const assert = require("node:assert");
+const { TDK } = require("../dist/index.js");
+
+async function runTests() {
+  console.log("=== Running Proofread Unit & Integration Tests ===");
+
+  // 1. Question Particle 'mi/mı/mu/mü'
+  console.log("1. Testing question particle detection...");
+  const q1 = await TDK.proofread("Sen dün okula gittinmi?");
+  assert.strictEqual(q1.isCorrect, false);
+  assert.strictEqual(q1.issues.length, 1);
+  assert.strictEqual(q1.issues[0].type, "question_particle");
+  assert.strictEqual(q1.issues[0].suggestion, "gittin mi");
+  console.log("  ✓ Question particle passed.");
+
+  // 2. Conjunction 'da/de'
+  console.log("2. Testing conjunction da/de detection...");
+  const d1 = await TDK.proofread("Sen gitsende ben kalacağım.");
+  assert.strictEqual(d1.isCorrect, false);
+  assert.strictEqual(d1.issues.length, 1);
+  assert.strictEqual(d1.issues[0].type, "conjunction_da");
+  assert.strictEqual(d1.issues[0].suggestion, "gitsen de");
+
+  // Normal locative 'evde' should NOT trigger issue
+  const d2 = await TDK.proofread("Bugün evde oturdum.");
+  assert.strictEqual(d2.isCorrect, true);
+  assert.strictEqual(d2.issues.length, 0);
+  console.log("  ✓ Conjunction da/de passed.");
+
+  // 3. Conjunction 'ki'
+  console.log("3. Testing conjunction ki detection...");
+  const k1 = await TDK.proofread("Anladımki beni dinlemiyorsun.");
+  assert.strictEqual(k1.isCorrect, false);
+  assert.strictEqual(k1.issues.length, 1);
+  assert.strictEqual(k1.issues[0].type, "conjunction_ki");
+  assert.strictEqual(k1.issues[0].suggestion, "anladım ki");
+
+  // SOMBAHÇEMİ exceptions like 'çünkü', 'oysaki' should NOT trigger issue
+  const k2 = await TDK.proofread("Oysaki seni çok sevmiştim çünkü güzeldin.");
+  assert.strictEqual(k2.isCorrect, true);
+  assert.strictEqual(k2.issues.length, 0);
+  console.log("  ✓ Conjunction ki passed.");
+
+  // 4. Combined sentence
+  console.log("4. Testing combined sentence proofread...");
+  const combo = await TDK.proofread("Gördümki gelmedin, bilsende gelirdin ve yaptınmı?");
+  assert.strictEqual(combo.isCorrect, false);
+  assert.strictEqual(combo.issues.length, 3);
+  assert.strictEqual(combo.issues.some((i) => i.type === "conjunction_ki"), true);
+  assert.strictEqual(combo.issues.some((i) => i.type === "conjunction_da"), true);
+  assert.strictEqual(combo.issues.some((i) => i.type === "question_particle"), true);
+  console.log("  ✓ Combined proofread passed.");
+
+  console.log("\n All proofread tests passed successfully!");
+}
+
+runTests().catch((err) => {
+  console.error("Test failed:", err);
+  process.exit(1);
+});

package/test/tools.test.js

@@ -0,0 +1,51 @@
+const assert = require("node:assert");
+const { TDK, TDKClient } = require("../dist/index.js");
+
+async function runTests() {
+  console.log("=== Running Linguistic Tools & Client Tests ===");
+
+  // 1. Pattern / Wildcard Search
+  console.log("1. Testing patternSearch...");
+  const p1 = await TDK.patternSearch("k_l_m");
+  assert(p1.includes("kalem"), "k_l_m must contain kalem");
+  assert(p1.includes("kilim"), "k_l_m must contain kilim");
+
+  const p2 = await TDK.patternSearch("*istan");
+  assert(p2.some((w) => w.toLowerCase().endsWith("istan")), "*istan must match words ending with istan");
+  console.log("  ✓ patternSearch passed.");
+
+  // 2. Anagram Solver
+  console.log("2. Testing findAnagrams...");
+  const a1 = await TDK.findAnagrams("kalem");
+  assert(a1.includes("kelam"), "Anagrams of kalem must contain kelam");
+  assert(a1.includes("kemal"), "Anagrams of kalem must contain kemal");
+  console.log("  ✓ findAnagrams passed.");
+
+  // 3. Rhyme Finder
+  console.log("3. Testing findRhymes...");
+  const r1 = await TDK.findRhymes("bahar");
+  assert(r1.includes("sonbahar") || r1.includes("ilkbahar") || r1.includes("buhar"));
+  console.log("  ✓ findRhymes passed.");
+
+  // 4. Configuration & TDKClient
+  console.log("4. Testing TDK.configure and TDKClient...");
+  TDK.configure({ timeoutMs: 10000, retries: 2, maxCacheSize: 500 });
+
+  const client = new TDKClient({ timeoutMs: 5000, cache: true });
+  assert.strictEqual(typeof client.getWord, "function");
+  assert.strictEqual(typeof client.checkSpelling, "function");
+  assert.strictEqual(typeof client.findRoot, "function");
+  assert.strictEqual(typeof client.proofread, "function");
+  assert.strictEqual(typeof client.patternSearch, "function");
+  assert.strictEqual(typeof client.findAnagrams, "function");
+  assert.strictEqual(typeof client.findRhymes, "function");
+  assert.strictEqual(typeof client.checkLabialHarmony, "function");
+  console.log("  ✓ TDKClient passed.");
+
+  console.log("\n All linguistic tools & client tests passed successfully!");
+}
+
+runTests().catch((err) => {
+  console.error("Test failed:", err);
+  process.exit(1);
+});