tdk-api-wrapper 1.4.0 → 1.5.1

package/src/types.ts

@@ -118,6 +118,7 @@ export interface WordComparisonSide {
   origin: string | null;
   syllables: string[];
   harmony: boolean;
+  labialHarmony?: boolean;
 }
 
 export interface WordComparison {
@@ -134,6 +135,42 @@ export interface WordAnalysis {
   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 {
   kelime: string;
   anlam: string;
@@ -145,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

@@ -1,5 +1,13 @@
 const assert = require("node:assert");
-const { TDK, getStemCandidates, restoreConsonantSoftening, restoreVowelDrop, restoreInfinitive } = require("../dist/index.js");
+const {
+  TDK,
+  getStemCandidates,
+  restoreConsonantSoftening,
+  restoreVowelDrop,
+  restoreInfinitive,
+  restoreGemination,
+  restoreVowelNarrowing,
+} = require("../dist/index.js");
 
 async function runTests() {
   console.log("=== Running Morphology Unit & Integration Tests ===");
@@ -16,6 +24,14 @@ async function runTests() {
   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
@@ -61,6 +77,9 @@ async function runTests() {
   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
@@ -74,6 +93,11 @@ async function runTests() {
   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

package/test/proofread.test.js

@@ -0,0 +1,88 @@
+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.");
+
+  // 5. Şey detachment check (herşey, hersey, birşeyler -> her şey, bir şeyler)
+  console.log("5. Testing -şey detachment...");
+  const s1 = await TDK.proofread("burda herşey yolunda");
+  assert.strictEqual(s1.isCorrect, false);
+  assert.strictEqual(s1.issues.length, 2);
+  assert.strictEqual(s1.issues[0].word, "burda");
+  assert.strictEqual(s1.issues[0].suggestion, "burada");
+  assert.strictEqual(s1.issues[1].word, "herşey");
+  assert.strictEqual(s1.issues[1].suggestion, "her şey");
+
+  const s2 = await TDK.proofread("hersey çok güzel");
+  assert.strictEqual(s2.isCorrect, false);
+  assert.strictEqual(s2.issues[0].word, "hersey");
+  assert.strictEqual(s2.issues[0].suggestion, "her şey");
+  console.log("  ✓ -şey detachment passed.");
+
+  // 6. Erroneously separated compound phrases (hiç bir, bir çok, git gide)
+  console.log("6. Testing compound phrases...");
+  const p1 = await TDK.proofread("hiç bir şey bilmiyor");
+  assert.strictEqual(p1.isCorrect, false);
+  assert.strictEqual(p1.issues[0].word, "hiç bir");
+  assert.strictEqual(p1.issues[0].suggestion, "hiçbir");
+
+  const p2 = await TDK.proofread("yada gelme");
+  assert.strictEqual(p2.isCorrect, false);
+  assert.strictEqual(p2.issues[0].suggestion, "ya da");
+  console.log("  ✓ Compound phrases 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);
+});