@moontra/moonui 6.24.0 → 6.26.0

package/src/components/ui/__tests__/progress-warning-error-contrast.test.ts

@@ -40,12 +40,12 @@ const KOK = path.resolve(__dirname, '../../..')
 const tokens = fs.readFileSync(path.join(KOK, 'styles/tokens.css'), 'utf8')
 
 /** "H S% L%" biçimindeki token değerini oku (light = :root, dark = .dark bloğu) */
-function tokenOku(ad: string, blok: 'light' | 'dark'): string | null {
-  const kaynak =
+function tokenOku(name: string, blok: 'light' | 'dark'): string | null {
+  const source =
     blok === 'dark'
       ? tokens.slice(tokens.indexOf('.dark'))
       : tokens.slice(0, tokens.indexOf('.dark'))
-  return kaynak.match(new RegExp(`--${ad}:\\s*([^;]+);`))?.[1].trim() ?? null
+  return source.match(new RegExp(`--${name}:\\s*([^;]+);`))?.[1].trim() ?? null
 }
 
 function hslToRgb(h: number, s: number, l: number): [number, number, number] {
@@ -75,7 +75,7 @@ const rgbTokenRgb = (v: string): [number, number, number] => {
   return [p[0], p[1], p[2]]
 }
 
-function bagilParlaklik([r, g, b]: [number, number, number]): number {
+function relativeLuminance([r, g, b]: [number, number, number]): number {
   const c = (v: number) => {
     const x = v / 255
     return x <= 0.03928 ? x / 12.92 : Math.pow((x + 0.055) / 1.055, 2.4)
@@ -84,8 +84,8 @@ function bagilParlaklik([r, g, b]: [number, number, number]): number {
 }
 
 function rgbKontrast(a: [number, number, number], b: [number, number, number]): number {
-  const la = bagilParlaklik(a)
-  const lb = bagilParlaklik(b)
+  const la = relativeLuminance(a)
+  const lb = relativeLuminance(b)
   const [hi, lo] = la > lb ? [la, lb] : [lb, la]
   return (hi + 0.05) / (lo + 0.05)
 }
@@ -94,12 +94,12 @@ function rgbKontrast(a: [number, number, number], b: [number, number, number]):
 function alfaBileske(
   ust: [number, number, number],
   alfa: number,
-  zemin: [number, number, number]
+  background: [number, number, number]
 ): [number, number, number] {
   return [
-    Math.round(alfa * ust[0] + (1 - alfa) * zemin[0]),
-    Math.round(alfa * ust[1] + (1 - alfa) * zemin[1]),
-    Math.round(alfa * ust[2] + (1 - alfa) * zemin[2]),
+    Math.round(alfa * ust[0] + (1 - alfa) * background[0]),
+    Math.round(alfa * ust[1] + (1 - alfa) * background[1]),
+    Math.round(alfa * ust[2] + (1 - alfa) * background[2]),
   ]
 }
 
@@ -108,23 +108,23 @@ function alfaBileske(
  * #284/#368 konvansiyonu: kontrast, --background'ın yanında bu gerçek yüzeye
  * göre de ölçülür. Bu zemin bu bulguda DARBOĞAZ: en düşük oranları o veriyor.
  */
-const KART_GERCEK_DARK: [number, number, number] = [17, 24, 39]
+const CARD_ACTUAL_DARK: [number, number, number] = [17, 24, 39]
 
 const AILELER = ['warning', 'error'] as const
 type Aile = (typeof AILELER)[number]
 
 /** Semantik token'ın ilgili temadaki değeri — `.dark` ezmesi YOKSA light'a düşer */
-function semantikRgb(aile: Aile, blok: 'light' | 'dark'): [number, number, number] {
+function semanticRgb(aile: Aile, blok: 'light' | 'dark'): [number, number, number] {
   return hslTokenRgb(tokenOku(aile, blok) ?? tokenOku(aile, 'light')!)
 }
 
 /** O temada track'in oluşabileceği tüm zeminler */
-function zeminler(blok: 'light' | 'dark'): Array<[string, [number, number, number]]> {
+function backgrounds(blok: 'light' | 'dark'): Array<[string, [number, number, number]]> {
   const z: Array<[string, [number, number, number]]> = [
     ['--background', hslTokenRgb(tokenOku('background', blok)!)],
     ['--card', hslTokenRgb(tokenOku('card', blok)!)],
   ]
-  if (blok === 'dark') z.push(['gerçek kart #111827', KART_GERCEK_DARK])
+  if (blok === 'dark') z.push(['gerçek kart #111827', CARD_ACTUAL_DARK])
   return z
 }
 
@@ -133,44 +133,44 @@ function zeminler(blok: 'light' | 'dark'): Array<[string, [number, number, numbe
 // dizgelerine göre yapıyoruz. Böylece aşağıdaki ≥3:1 testleri component'e
 // GERÇEKTEN bağlanır: biri dolguyu eski hâline döndürürse (ya da track alfasını
 // oynatırsa) kriter testi kırmızı olur — yalnız sözleşme testleri değil.
-const kaynak = fs.readFileSync(path.join(KOK, 'components/ui/progress.tsx'), 'utf8')
-const AYRAC = kaynak.indexOf('progressIndicatorVariants')
-const TRACK_BLOK = kaynak.slice(0, AYRAC)
-const DOLGU_BLOK = kaynak.slice(AYRAC)
+const source = fs.readFileSync(path.join(KOK, 'components/ui/progress.tsx'), 'utf8')
+const AYRAC = source.indexOf('progressIndicatorVariants')
+const TRACK_BLOK = source.slice(0, AYRAC)
+const FILL_BLOCK = source.slice(AYRAC)
 
 /** CVA bloğundan `<aile>: "<sınıflar>"` değerini oku */
-function varyantSinifi(blok: string, aile: Aile): string {
+function variantClass(blok: string, aile: Aile): string {
   const m = blok.match(new RegExp(`\\n\\s*${aile}:\\s*"([^"]+)"`))
   if (!m) throw new Error(`${aile} varyantı bulunamadı`)
   return m[1]
 }
 
 /** Tek bir Tailwind bg sınıfını renge çevir (arbitrary skala VEYA semantik token) */
-function sinifRengi(sinif: string, blok: 'light' | 'dark'): [number, number, number] {
-  const skala = sinif.match(/^bg-\[rgb\(var\(--([a-z0-9-]+)\)\)\]$/)
-  if (skala) return rgbTokenRgb(tokenOku(skala[1], 'light')!) // skala yalnız :root'ta
-  const semantik = sinif.match(/^bg-([a-z-]+)$/)
-  if (semantik) return hslTokenRgb(tokenOku(semantik[1], blok) ?? tokenOku(semantik[1], 'light')!)
-  throw new Error(`çözülemeyen sınıf: ${sinif}`)
+function classColor(cls: string, blok: 'light' | 'dark'): [number, number, number] {
+  const scale = cls.match(/^bg-\[rgb\(var\(--([a-z0-9-]+)\)\)\]$/)
+  if (scale) return rgbTokenRgb(tokenOku(scale[1], 'light')!) // skala yalnız :root'ta
+  const semantic = cls.match(/^bg-([a-z-]+)$/)
+  if (semantic) return hslTokenRgb(tokenOku(semantic[1], blok) ?? tokenOku(semantic[1], 'light')!)
+  throw new Error(`çözülemeyen sınıf: ${cls}`)
 }
 
 /** Dolgunun o temada GERÇEKTEN uygulanan rengi — `dark:` öneki dark'ta kazanır */
-function dolguRengi(aile: Aile, blok: 'light' | 'dark'): [number, number, number] {
-  const siniflar = varyantSinifi(DOLGU_BLOK, aile).split(/\s+/)
-  const darkSinif = siniflar.find((s) => s.startsWith('dark:'))?.slice('dark:'.length)
-  const lightSinif = siniflar.find((s) => !s.startsWith('dark:'))
-  if (!lightSinif) throw new Error(`${aile}: temel (light) sınıf yok`)
-  return sinifRengi(blok === 'dark' ? darkSinif ?? lightSinif : lightSinif, blok)
+function fillColor(aile: Aile, blok: 'light' | 'dark'): [number, number, number] {
+  const classNames = variantClass(FILL_BLOCK, aile).split(/\s+/)
+  const darkClass = classNames.find((s) => s.startsWith('dark:'))?.slice('dark:'.length)
+  const lightClass = classNames.find((s) => !s.startsWith('dark:'))
+  if (!lightClass) throw new Error(`${aile}: temel (light) sınıf yok`)
+  return classColor(blok === 'dark' ? darkClass ?? lightClass : lightClass, blok)
 }
 
 /** Track'in o zemin üstündeki bileşke rengi — alfa da kaynaktan okunur */
 function trackler(aile: Aile, blok: 'light' | 'dark') {
-  const sinif = varyantSinifi(TRACK_BLOK, aile)
-  const m = sinif.match(/^bg-([a-z-]+)\/(\d+)$/)
-  if (!m) throw new Error(`track sınıfı çözülemedi: ${sinif}`)
-  const taban = hslTokenRgb(tokenOku(m[1], blok) ?? tokenOku(m[1], 'light')!)
+  const cls = variantClass(TRACK_BLOK, aile)
+  const m = cls.match(/^bg-([a-z-]+)\/(\d+)$/)
+  if (!m) throw new Error(`track sınıfı çözülemedi: ${cls}`)
+  const base = hslTokenRgb(tokenOku(m[1], blok) ?? tokenOku(m[1], 'light')!)
   const alfa = Number(m[2]) / 100
-  return zeminler(blok).map(([ad, z]) => [ad, alfaBileske(taban, alfa, z)] as const)
+  return backgrounds(blok).map(([name, z]) => [name, alfaBileske(base, alfa, z)] as const)
 }
 
 const KADEMELER = [50, 100, 200, 300, 400, 500, 600, 700, 800, 900, 950]
@@ -192,8 +192,8 @@ describe('#424 progress warning/error dolgu↔track kontrastı', () => {
     // warning dolgu rgb(245,159,10) / track rgb(253,236,206), error dolgu
     // rgb(239,67,67) / track rgb(252,217,217). Model bunları tutturamıyorsa
     // aşağıdaki tüm oranlar anlamsızdır.
-    expect(semantikRgb('warning', 'light')).toEqual([245, 159, 10])
-    expect(semantikRgb('error', 'light')).toEqual([239, 67, 67])
+    expect(semanticRgb('warning', 'light')).toEqual([245, 159, 10])
+    expect(semanticRgb('error', 'light')).toEqual([239, 67, 67])
     expect(trackler('warning', 'light')[0][1]).toEqual([253, 236, 206])
     expect(trackler('error', 'light')[0][1]).toEqual([252, 217, 217])
   })
@@ -204,7 +204,7 @@ describe('#424 progress warning/error dolgu↔track kontrastı', () => {
       // `--warning`/`--error` eklerse bu test kırmızı olur ve component
       // düzeyindeki `dark:` telafisinin yeniden ölçülmesi gerektiğini söyler.
       expect(tokenOku(aile, 'dark')).toBeNull()
-      expect(semantikRgb(aile, 'light')).toEqual(semantikRgb(aile, 'dark'))
+      expect(semanticRgb(aile, 'light')).toEqual(semanticRgb(aile, 'dark'))
     })
 
     it('karşıtlık: --success tema-uyarlanabilir olduğu İÇİN eşiği geçiyor', () => {
@@ -226,11 +226,11 @@ describe('#424 progress warning/error dolgu↔track kontrastı', () => {
 
   describe('kaynak sözleşmesi: dolgu ile track FARKLI renklere basıyor', () => {
     it.each(AILELER)('track %s sınıfı `/20` alfasını KORUYOR (altı varyantın ortak deseni)', (aile) => {
-      expect(kaynak).toMatch(new RegExp(`${aile}:\\s*"bg-${aile}\\/20"`))
+      expect(source).toMatch(new RegExp(`${aile}:\\s*"bg-${aile}\\/20"`))
     })
 
     it.each(AILELER)('dolgu %s sınıfı light\'ta -700, dark\'ta semantik token', (aile) => {
-      expect(kaynak).toMatch(
+      expect(source).toMatch(
         new RegExp(`${aile}:\\s*"bg-\\[rgb\\(var\\(--${aile}-700\\)\\)\\] dark:bg-${aile}"`)
       )
     })
@@ -241,22 +241,22 @@ describe('#424 progress warning/error dolgu↔track kontrastı', () => {
       render(React.createElement(Progress, { variant: aile, value: 50 }))
       const track = screen.getByRole('progressbar')
       expect(track).toHaveClass(`bg-${aile}/20`)
-      const dolgu = track.firstElementChild as HTMLElement
-      expect(dolgu).not.toBeNull()
-      expect(dolgu.className).toContain(`bg-[rgb(var(--${aile}-700))]`)
-      expect(dolgu.className).toContain(`dark:bg-${aile}`)
+      const fill = track.firstElementChild as HTMLElement
+      expect(fill).not.toBeNull()
+      expect(fill.className).toContain(`bg-[rgb(var(--${aile}-700))]`)
+      expect(fill.className).toContain(`dark:bg-${aile}`)
       // Light'ta semantik token dolguya UYGULANMAMALI (track'in aynısıydı):
       // yalnız `dark:` önekli hâli kalmalı.
-      expect(dolgu.className).not.toMatch(new RegExp(`(?:^|\\s)bg-${aile}(?:\\s|$)`))
+      expect(fill.className).not.toMatch(new RegExp(`(?:^|\\s)bg-${aile}(?:\\s|$)`))
     })
 
     it.each(AILELER)('#318 düşüş mantığı KORUNUYOR — indicatorVariant hâlâ %s varyantını ezer', (aile) => {
       render(
         React.createElement(Progress, { variant: aile, indicatorVariant: 'success', value: 50 })
       )
-      const dolgu = screen.getByRole('progressbar').firstElementChild as HTMLElement
-      expect(dolgu.className).toContain('bg-success')
-      expect(dolgu.className).not.toContain(`--${aile}-700`)
+      const fill = screen.getByRole('progressbar').firstElementChild as HTMLElement
+      expect(fill.className).toContain('bg-success')
+      expect(fill.className).not.toContain(`--${aile}-700`)
     })
   })
 
@@ -264,10 +264,10 @@ describe('#424 progress warning/error dolgu↔track kontrastı', () => {
     it.each(['light', 'dark'] as const)('%s temada TÜM zeminlerde eşiği geçiyor', (blok) => {
       // Ölçülen: warning light 4.24 · dark 6.97 (docs kartı 5.77)
       //          error   light 4.95 · dark 4.46 (docs kartı 3.82)
-      const dolgu = dolguRengi(aile, blok)
-      for (const [ad, track] of trackler(aile, blok)) {
-        const oran = rgbKontrast(dolgu, track)
-        expect({ zemin: ad, gecti: oran >= 3.0 }).toEqual({ zemin: ad, gecti: true })
+      const fill = fillColor(aile, blok)
+      for (const [name, track] of trackler(aile, blok)) {
+        const oran = rgbKontrast(fill, track)
+        expect({ background: name, didPass: oran >= 3.0 }).toEqual({ background: name, didPass: true })
       }
     })
 
@@ -275,18 +275,18 @@ describe('#424 progress warning/error dolgu↔track kontrastı', () => {
       // warning 1.83 · error 2.89. Bu test düzeltmenin GEREKLİLİĞİNİ sabitler:
       // biri dolguyu `bg-warning`/`bg-error`e geri döndürürse üstteki kriter
       // testi kırmızı olur, burası da nedenini belgeler.
-      const eski = semantikRgb(aile, 'light')
+      const old = semanticRgb(aile, 'light')
       for (const [, track] of trackler(aile, 'light')) {
-        expect(rgbKontrast(eski, track)).toBeLessThan(3.0)
+        expect(rgbKontrast(old, track)).toBeLessThan(3.0)
       }
     })
 
     it('DARK render değişmedi — eski dolgu dark\'ta zaten geçiyordu ve hâlâ o renk', () => {
       // Bulgu light'a özgüydü; düzeltmenin dark'ta hiçbir şeyi oynatmaması
       // bilinçli bir kısıt (regresyon yüzeyini sıfıra indirir).
-      expect(dolguRengi(aile, 'dark')).toEqual(semantikRgb(aile, 'dark'))
+      expect(fillColor(aile, 'dark')).toEqual(semanticRgb(aile, 'dark'))
       for (const [, track] of trackler(aile, 'dark')) {
-        expect(rgbKontrast(semantikRgb(aile, 'dark'), track)).toBeGreaterThanOrEqual(3.0)
+        expect(rgbKontrast(semanticRgb(aile, 'dark'), track)).toBeGreaterThanOrEqual(3.0)
       }
     })
   })
@@ -297,7 +297,7 @@ describe('#424 progress warning/error dolgu↔track kontrastı', () => {
       // (gerçek docs kartı zemininde) eşiğin ALTINDA: warning 2.50 · error 2.23.
       // `dark:` ayrımı tam olarak bunu önlüyor.
       const k700 = rgbTokenRgb(tokenOku(`${aile}-700`, 'light')!)
-      const docsTrack = trackler(aile, 'dark').find(([ad]) => ad === 'gerçek kart #111827')![1]
+      const docsTrack = trackler(aile, 'dark').find(([name]) => name === 'gerçek kart #111827')![1]
       expect(rgbKontrast(k700, docsTrack)).toBeLessThan(3.0)
     })
 
@@ -308,23 +308,23 @@ describe('#424 progress warning/error dolgu↔track kontrastı', () => {
       // skalanın 11 kademesinin HİÇBİRİ tema-kör olarak iki temayı birden
       // geçemiyor. Bu, `dark:` ayrımını zorunlu kılan kanıttır.
       const tumTrackler = [...trackler(aile, 'light'), ...trackler(aile, 'dark')]
-      const gecen = KADEMELER.filter((k) => {
+      const passedCount = KADEMELER.filter((k) => {
         const ham = tokenOku(`${aile}-${k}`, 'light')
         if (!ham) return false
         const d = rgbTokenRgb(ham)
         return tumTrackler.every(([, t]) => rgbKontrast(d, t) >= 3.0)
       })
-      expect(gecen).toEqual([])
+      expect(passedCount).toEqual([])
     })
 
     it.each(AILELER)('%s track alfası düşürülmedi — /20 ayrımı /10\'dan güçlü', (aile) => {
       // Alternatif öneri track'i `/10`'a çekmekti; kabul edilmedi çünkü track
       // zemine yaklaşır ve barın TOPLAM uzunluğu görünmez olur. Altı varyantın
       // ortak `/20` deseni de bozulurdu.
-      const zemin = zeminler('light')[0][1]
-      const sem = semantikRgb(aile, 'light')
-      const yirmi = rgbKontrast(alfaBileske(sem, 0.2, zemin), zemin)
-      const on = rgbKontrast(alfaBileske(sem, 0.1, zemin), zemin)
+      const background = backgrounds('light')[0][1]
+      const sem = semanticRgb(aile, 'light')
+      const yirmi = rgbKontrast(alfaBileske(sem, 0.2, background), background)
+      const on = rgbKontrast(alfaBileske(sem, 0.1, background), background)
       expect(yirmi).toBeGreaterThan(on)
     })
   })

package/src/components/ui/__tests__/quality-group-de.test.tsx

@@ -152,8 +152,8 @@ describe('#308-5/6 command', () => {
       </Command>
     )
     const listbox = container.querySelector('[role="listbox"]')!
-    const gorunurCocuklar = Array.from(listbox.querySelectorAll('[role="separator"]'))
+    const visibleChildren = Array.from(listbox.querySelectorAll('[role="separator"]'))
       .filter((el) => el.getAttribute('aria-hidden') !== 'true')
-    expect(gorunurCocuklar).toHaveLength(0)
+    expect(visibleChildren).toHaveLength(0)
   })
 })

package/src/components/ui/__tests__/responsive-color-invariance.test.ts

@@ -25,31 +25,31 @@ const KOKLER = [
 ]
 
 /** Renk ailesinden yardımcı adları — boyut/hiza/spacing DEĞİL. */
-const RENK_ONEKLERI = ['text', 'bg', 'border', 'from', 'via', 'to', 'ring', 'divide',
+const COLOR_PREFIXES = ['text', 'bg', 'border', 'from', 'via', 'to', 'ring', 'divide',
   'placeholder', 'decoration', 'caret', 'accent', 'outline', 'shadow']
 
 /** `text-*` ailesinde renk OLMAYAN değerler (boyut, hiza, taşma). */
-const RENK_OLMAYAN_TEXT = new Set([
+const NON_COLOR_TEXT = new Set([
   'xs','sm','base','lg','xl','2xl','3xl','4xl','5xl','6xl','7xl','8xl','9xl',
   'left','center','right','justify','start','end',
   'wrap','nowrap','balance','pretty','clip','ellipsis',
 ])
 
-function dosyalar(kok: string): string[] {
-  const cikti: string[] = []
-  if (!fs.existsSync(kok)) return cikti
+function files(root: string): string[] {
+  const output: string[] = []
+  if (!fs.existsSync(root)) return output
   ;(function walk(dir: string) {
     for (const e of fs.readdirSync(dir, { withFileTypes: true })) {
       const p = path.join(dir, e.name)
       if (e.isDirectory()) {
         if (!/node_modules|__tests__|dist/.test(p)) walk(p)
-      } else if (/\.(tsx?|css)$/.test(e.name)) cikti.push(p)
+      } else if (/\.(tsx?|css)$/.test(e.name)) output.push(p)
     }
-  })(kok)
-  return cikti
+  })(root)
+  return output
 }
 
-const tumDosyalar = KOKLER.flatMap(dosyalar)
+const tumDosyalar = KOKLER.flatMap(files)
 const RESPONSIVE = /\b(sm|md|lg|xl|2xl):([a-z][a-z0-9-]*)(?:-([a-z0-9[\]#/.%-]+))?/g
 
 describe('#354 responsive renk değişmezi', () => {
@@ -62,31 +62,31 @@ describe('#354 responsive renk değişmezi', () => {
     // günkü değer 202'ydi; #365'te ölü `dashboard/demo.tsx` (3 varyant) silinince
     // kırmızıya döndü — regex bozulmadan. Amaç "tarayıcı ölü mü" sorusunu
     // yanıtlamak olduğundan büyüklük mertebesi yeterli.
-    let toplam = 0
+    let total = 0
     for (const f of tumDosyalar) {
-      toplam += [...fs.readFileSync(f, 'utf8').matchAll(RESPONSIVE)].length
+      total += [...fs.readFileSync(f, 'utf8').matchAll(RESPONSIVE)].length
     }
-    expect(toplam).toBeGreaterThan(100)
+    expect(total).toBeGreaterThan(100)
     expect(tumDosyalar.length).toBeGreaterThan(100)
   })
 
   it('hiçbir kırılma noktası RENK değiştirmiyor', () => {
-    const ihlaller: string[] = []
+    const violations: string[] = []
     for (const f of tumDosyalar) {
       const src = fs.readFileSync(f, 'utf8')
       for (const m of src.matchAll(RESPONSIVE)) {
-        const [tam, , yardimci, deger] = m
-        if (!RENK_ONEKLERI.includes(yardimci)) continue
-        if (!deger) continue
+        const [tam, , helper, value] = m
+        if (!COLOR_PREFIXES.includes(helper)) continue
+        if (!value) continue
         // `text-` ailesinde boyut/hiza değerleri renk değildir
-        if (yardimci === 'text' && RENK_OLMAYAN_TEXT.has(deger)) continue
+        if (helper === 'text' && NON_COLOR_TEXT.has(value)) continue
         // köşeli parantezli keyfi değerler: renk mi boyut mu? `#`/`rgb` varsa renk.
-        if (deger.startsWith('[') && !/#|rgb|hsl/.test(deger)) continue
-        ihlaller.push(`${path.basename(f)} → ${tam}`)
+        if (value.startsWith('[') && !/#|rgb|hsl/.test(value)) continue
+        violations.push(`${path.basename(f)} → ${tam}`)
       }
     }
     // Boş olmalı: aksi halde contrast ölçümü artık viewport'a bağımlıdır ve
     // #354'ün "tek genişlikte ölçmek yeterli" gerekçesi düşer.
-    expect(ihlaller).toEqual([])
+    expect(violations).toEqual([])
   })
 })

package/src/components/ui/__tests__/select.test.tsx

@@ -393,9 +393,14 @@ describe('Select Components', () => {
       item = screen.getByTestId('select-item')
       expect(item).toHaveClass('text-success')
 
+      // #623: `text-warning` (DEFAULT token) açık temada beyaz zeminde 2.14:1 ölçüldü —
+      // AA'nın (4.5) ve hatta büyük-metin eşiğinin (3.0) altında. `--warning` aynı zamanda
+      // `bg-warning` yüzeylerinde kullanıldığı için token'ın kendisi DEĞİŞTİRİLMEDİ;
+      // metin rengi ölçülmüş bir light/dark çiftine taşındı: 4.92 (light) / 10.51 (dark).
       rerender(<SelectItem value="item1" variant="warning">Item</SelectItem>)
       item = screen.getByTestId('select-item')
-      expect(item).toHaveClass('text-warning')
+      expect(item).toHaveClass('text-warning-700')
+      expect(item).toHaveClass('dark:text-warning-500')
     })
 
     it('applies size classes correctly', () => {

package/src/components/ui/__tests__/semantic-token-usage.test.ts

@@ -20,16 +20,16 @@ import * as path from 'path'
 const HAM_PALET = /\b(?:bg|text|border|ring|from|to|via)-(red|green|yellow|orange|blue)-\d{2,3}\b/
 
 /** Durum varyantı adları — cva içinde bu anahtarların değerleri token kullanmalı. */
-const DURUM_ANAHTARLARI = ['destructive', 'success', 'warning', 'info', 'error']
+const STATUS_KEYS = ['destructive', 'success', 'warning', 'info', 'error']
 
 interface Ihlal {
   file: string
   line: number
-  anahtar: string
-  parca: string
+  key: string
+  part: string
 }
 
-function tara(root: string): Ihlal[] {
+function scan(root: string): Ihlal[] {
   const files: string[] = []
   ;(function walk(dir: string) {
     if (!fs.existsSync(dir)) return
@@ -41,27 +41,27 @@ function tara(root: string): Ihlal[] {
     }
   })(root)
 
-  const ihlaller: Ihlal[] = []
+  const violations: Ihlal[] = []
   for (const f of files) {
     const src = fs.readFileSync(f, 'utf8')
-    for (const anahtar of DURUM_ANAHTARLARI) {
+    for (const key of STATUS_KEYS) {
       // `destructive: "…"` biçimindeki cva varyant girdisini yakala
-      const re = new RegExp(`\\n[ \\t]*${anahtar}:\\s*(["'])([\\s\\S]*?)\\1`, 'g')
+      const re = new RegExp(`\\n[ \\t]*${key}:\\s*(["'])([\\s\\S]*?)\\1`, 'g')
       for (const m of src.matchAll(re)) {
-        const deger = m[2]
-        const hit = deger.match(HAM_PALET)
+        const value = m[2]
+        const hit = value.match(HAM_PALET)
         if (hit) {
-          ihlaller.push({
+          violations.push({
             file: path.relative(process.cwd(), f),
             line: src.slice(0, m.index).split('\n').length + 1,
-            anahtar,
-            parca: hit[0],
+            key,
+            part: hit[0],
           })
         }
       }
     }
   }
-  return ihlaller
+  return violations
 }
 
 /**
@@ -76,12 +76,12 @@ function tara(root: string): Ihlal[] {
  * Takip işi bu dosyaları dönüştürüp satırları buradan siler — liste boşalınca kural
  * tam sıkı hale gelir.
  */
-const BILINEN_KALANLAR: string[] = []
+const KNOWN_REMAINING: string[] = []
 
 const SRC_ROOT = path.resolve(__dirname, '../../..')
-const tumIhlaller = tara(SRC_ROOT)
-const ihlaller = tumIhlaller.filter(
-  (i) => !BILINEN_KALANLAR.some((b) => i.file.replace(/\\/g, '/').endsWith(b))
+const tumIhlaller = scan(SRC_ROOT)
+const violations = tumIhlaller.filter(
+  (i) => !KNOWN_REMAINING.some((b) => i.file.replace(/\\/g, '/').endsWith(b))
 )
 
 describe('#313/#314/#323 semantik durum varyantları token kullanır', () => {
@@ -96,18 +96,18 @@ describe('#313/#314/#323 semantik durum varyantları token kullanır', () => {
   })
 
   it('durum varyantlarında ham Tailwind paleti YOK (bilinen kalanlar hariç)', () => {
-    const rapor = ihlaller.map((i) => `${i.file}:${i.line} → ${i.anahtar} içinde "${i.parca}"`)
-    expect(rapor).toEqual([])
+    const report = violations.map((i) => `${i.file}:${i.line} → ${i.key} içinde "${i.part}"`)
+    expect(report).toEqual([])
   })
 
   it('cırcır listesi ÇALIŞIYOR — listelenen dosyalar gerçekten hâlâ ihlalli', () => {
     // Bir dosya dönüştürüldüğünde bu test kırmızı olur ve satırı listeden silmeyi hatırlatır.
     // Aksi hâlde liste sonsuza dek şişer ve kural sessizce gevşer.
-    const halaIhlalli = new Set(
-      tumIhlaller.map((i) => BILINEN_KALANLAR.find((b) => i.file.replace(/\\/g, '/').endsWith(b)))
+    const stillViolating = new Set(
+      tumIhlaller.map((i) => KNOWN_REMAINING.find((b) => i.file.replace(/\\/g, '/').endsWith(b)))
     )
-    const gereksizListelenen = BILINEN_KALANLAR.filter((b) => !halaIhlalli.has(b))
-    expect(gereksizListelenen).toEqual([])
+    const redundantlyListed = KNOWN_REMAINING.filter((b) => !stillViolating.has(b))
+    expect(redundantlyListed).toEqual([])
   })
 
   it('toast success/warning/info gerçekten `--*-subtle` token\'larını kullanıyor', () => {

package/src/components/ui/__tests__/size-scale-convention.test.ts

@@ -109,7 +109,7 @@ describe('#319 size skalası konvansiyonu (free)', () => {
   })
 
   it('`default` yalnız SAF ALIAS olarak var — başka bir basamakla aynı değeri taşır', () => {
-    const ihlaller = maps
+    const violations = maps
       .filter((m) => m.entries.some(([k]) => k === DEPRECATED_ALIAS))
       .filter((m) => {
         const val = m.entries.find(([k]) => k === DEPRECATED_ALIAS)![1]
@@ -117,14 +117,14 @@ describe('#319 size skalası konvansiyonu (free)', () => {
         return !m.entries.some(([k, v]) => k !== DEPRECATED_ALIAS && v === val)
       })
       .map((m) => `${m.file}:${m.line}`)
-    expect(ihlaller).toEqual([])
+    expect(violations).toEqual([])
   })
 
   it('`defaultVariants.size` kanonik bir ada işaret eder, `default`a DEĞİL', () => {
-    const ihlaller = maps
+    const violations = maps
       .filter((m) => m.defaultVariant === DEPRECATED_ALIAS)
       .map((m) => `${m.file}:${m.line}`)
-    expect(ihlaller).toEqual([])
+    expect(violations).toEqual([])
   })
 
   /**
@@ -137,7 +137,7 @@ describe('#319 size skalası konvansiyonu (free)', () => {
    * yazan tüketici, prop hiç vermemiş gibi bir sonuç alır.
    */
   it('`default`, `defaultVariants`ın işaret ettiği basamakla AYNI değeri üretir', () => {
-    const ihlaller = maps
+    const violations = maps
       .filter((m) => m.entries.some(([k]) => k === DEPRECATED_ALIAS))
       .filter((m) => {
         const aliasVal = m.entries.find(([k]) => k === DEPRECATED_ALIAS)![1]
@@ -145,7 +145,7 @@ describe('#319 size skalası konvansiyonu (free)', () => {
         return dvVal === undefined || aliasVal !== dvVal
       })
       .map((m) => `${m.file}:${m.line} (default→"${m.defaultVariant}")`)
-    expect(ihlaller).toEqual([])
+    expect(violations).toEqual([])
   })
 
   /**
@@ -165,7 +165,7 @@ describe('#319 size skalası konvansiyonu (free)', () => {
       }
     })(SRC_ROOT)
 
-    const ihlaller: string[] = []
+    const violations: string[] = []
     for (const f of files) {
       const src = fs.readFileSync(f, 'utf8')
       for (const m of src.matchAll(/\bsize\??\s*:\s*((?:"[a-zA-Z0-9_]+"\s*\|\s*)+"[a-zA-Z0-9_]+")/g)) {
@@ -174,16 +174,16 @@ describe('#319 size skalası konvansiyonu (free)', () => {
 
         // (a) sözlük dışı bir değer
         const disi = values.filter((v) => !ALLOWED.has(v))
-        if (disi.length) ihlaller.push(`${yer} → sözlük dışı: ${disi.join(', ')}`)
+        if (disi.length) violations.push(`${yer} → sözlük dışı: ${disi.join(', ')}`)
 
         // (b) `default` ALIAS'tır: kanonik adın YERİNE geçemez, yanında durur.
         //     `"sm" | "default" | "lg"` gibi bir union `md`yi hiç sunmadığı için ihlaldir —
         //     color-picker tam olarak bu şekilde migrasyondan kaçmıştı.
         if (values.includes(DEPRECATED_ALIAS) && !values.includes('md')) {
-          ihlaller.push(`${yer} → \`default\` var ama kanonik \`md\` YOK`)
+          violations.push(`${yer} → \`default\` var ama kanonik \`md\` YOK`)
         }
       }
     }
-    expect(ihlaller).toEqual([])
+    expect(violations).toEqual([])
   })
 })