@moontra/moonui 6.24.0 → 6.26.0

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

@@ -44,12 +44,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] {
@@ -79,7 +79,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)
@@ -88,8 +88,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)
 }
@@ -98,12 +98,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]),
   ]
 }
 
@@ -112,23 +112,23 @@ function alfaBileske(
  * #284/#368 konvansiyonu: kontrast, --background'ın yanında bu gerçek yüzeye göre
  * de ölçülür. Bu bulguda DARBOĞAZ: en düşük dark oranlarını 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 slider'ın oturabileceğ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
 }
 
@@ -136,30 +136,30 @@ function zeminler(blok: 'light' | 'dark'): Array<[string, [number, number, numbe
 // PR #440'ın dersi: ölçümü `-700` VARSAYIMINA göre yaparsan, biri değeri eskiye
 // döndürdüğünde kriter testleri yeşil kalır (boş-yeşil). Bu yüzden renkler
 // slider.tsx'in O ANKİ CVA sınıf dizgelerinden çözülür.
-const kaynak = fs.readFileSync(path.join(KOK, 'components/ui/slider.tsx'), 'utf8')
-const iTrack = kaynak.indexOf('sliderTrackVariants')
-const iRange = kaynak.indexOf('sliderRangeVariants')
-const iThumb = kaynak.indexOf('sliderThumbVariants')
-const iSon = kaynak.indexOf('SliderBaseProps')
-const TRACK_BLOK = kaynak.slice(iTrack, iRange)
-const RANGE_BLOK = kaynak.slice(iRange, iThumb)
-const THUMB_BLOK = kaynak.slice(iThumb, iSon)
+const source = fs.readFileSync(path.join(KOK, 'components/ui/slider.tsx'), 'utf8')
+const iTrack = source.indexOf('sliderTrackVariants')
+const iRange = source.indexOf('sliderRangeVariants')
+const iThumb = source.indexOf('sliderThumbVariants')
+const iSon = source.indexOf('SliderBaseProps')
+const TRACK_BLOK = source.slice(iTrack, iRange)
+const RANGE_BLOK = source.slice(iRange, iThumb)
+const THUMB_BLOK = source.slice(iThumb, iSon)
 
 /** CVA bloğundan `<aile>: "<sınıflar>"` değerini oku */
-function varyantSinifi(blok: string, aile: string): string {
+function variantClass(blok: string, aile: string): 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 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|border)-\[rgb\(var\(--([a-z0-9-]+)\)\)\]$/)
-  if (skala) return rgbTokenRgb(tokenOku(skala[1], 'light')!) // skala yalnız :root'ta
-  const semantik = sinif.match(/^(?:bg|border)-([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|border)-\[rgb\(var\(--([a-z0-9-]+)\)\)\]$/)
+  if (scale) return rgbTokenRgb(tokenOku(scale[1], 'light')!) // skala yalnız :root'ta
+  const semantic = cls.match(/^(?:bg|border)-([a-z-]+)$/)
+  if (semantic)
+    return hslTokenRgb(tokenOku(semantic[1], blok) ?? tokenOku(semantic[1], 'light')!)
+  throw new Error(`çözülemeyen sınıf: ${cls}`)
 }
 
 /**
@@ -167,40 +167,40 @@ function sinifRengi(sinif: string, blok: 'light' | 'dark'): [number, number, num
  * `dark:` önekli sınıf dark temada kazanır; `onek` ile eksen seçilir
  * (thumb dizgesi `border-*` yanında `bg-background` da taşır).
  */
-function uygulananRenk(
+function appliedColor(
   cvaBlok: string,
   aile: Aile,
   onek: 'bg' | 'border',
   blok: 'light' | 'dark'
 ): [number, number, number] {
-  const siniflar = varyantSinifi(cvaBlok, aile)
+  const classNames = variantClass(cvaBlok, aile)
     .split(/\s+/)
     .filter((s) => s.replace(/^dark:/, '').startsWith(`${onek}-`))
-  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}/${onek}: temel (light) sınıf yok`)
-  return sinifRengi(blok === 'dark' ? darkSinif ?? lightSinif : lightSinif, blok)
+  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}/${onek}: temel (light) sınıf yok`)
+  return classColor(blok === 'dark' ? darkClass ?? lightClass : lightClass, blok)
 }
 
 const rangeRengi = (aile: Aile, blok: 'light' | 'dark') =>
-  uygulananRenk(RANGE_BLOK, aile, 'bg', blok)
-const thumbKenarRengi = (aile: Aile, blok: 'light' | 'dark') =>
-  uygulananRenk(THUMB_BLOK, aile, 'border', blok)
+  appliedColor(RANGE_BLOK, aile, 'bg', blok)
+const thumbBorderColor = (aile: Aile, blok: 'light' | 'dark') =>
+  appliedColor(THUMB_BLOK, aile, 'border', blok)
 
 /** Track'in her zemin üstündeki bileşkesi — 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]
 
 /** Slider DOM'u: kök > .moonui-theme > track > range; thumb'lar track'in KARDEŞİ */
-function parcalar(container: HTMLElement) {
+function parts(container: HTMLElement) {
   const kabuk = container.querySelector('.moonui-theme') as HTMLElement
   expect(kabuk).not.toBeNull()
   const track = kabuk.firstElementChild as HTMLElement
@@ -226,8 +226,8 @@ describe('#442 slider warning/error — hesaplayıcı çapası', () => {
   it('hesaplayıcı, denetimin TARAYICIDA ölçtüğü renkleri birebir üretiyor', () => {
     // Çapraz doğrulama (#424/#442 gövdesindeki gerçek tarayıcı ölçümleri): 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])
   })
@@ -239,7 +239,7 @@ describe('#442 kök neden: --warning ve --error `.dark` bloğunda EZİLMİYOR',
     // `--error` eklerse burası 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', () => {
@@ -262,13 +262,13 @@ describe('#442 kök neden: --warning ve --error `.dark` bloğunda EZİLMİYOR',
     // Hesap, track'in/tutamacın altındaki yüzeyin --background/--card olduğunu
     // VARSAYAR. Biri `.moonui-theme`i token kapsamına çevirirse o varsayım
     // sessizce yanlışlanır — o an burası kırmızı olur (#389 deseni).
-    const stilDizini = path.join(KOK, 'styles')
-    const stiller = fs
-      .readdirSync(stilDizini)
+    const styleDir = path.join(KOK, 'styles')
+    const styles = fs
+      .readdirSync(styleDir)
       .filter((f) => f.endsWith('.css'))
-      .map((f) => fs.readFileSync(path.join(stilDizini, f), 'utf8'))
+      .map((f) => fs.readFileSync(path.join(styleDir, f), 'utf8'))
       .join('\n')
-    expect(stiller).not.toMatch(/\.moonui-theme[^{]*\{[^}]*--(warning|error|background|card)/)
+    expect(styles).not.toMatch(/\.moonui-theme[^{]*\{[^}]*--(warning|error|background|card)/)
   })
 })
 
@@ -276,17 +276,17 @@ describe('#442 kaynak sözleşmesi — slider.tsx', () => {
   it.each(AILELER)('track %s sınıfı `/20` alfasını KORUYOR (yedi varyantın ortak deseni)', (aile) => {
     // Alternatif öneri track'i `/10`'a çekmekti; kabul edilmedi (track↔zemin
     // ayrımını zayıflatır, ortak konvansiyonu bozar). Burası o kararı kilitler.
-    expect(varyantSinifi(TRACK_BLOK, aile)).toBe(`bg-${aile}/20`)
+    expect(variantClass(TRACK_BLOK, aile)).toBe(`bg-${aile}/20`)
   })
 
   it.each(AILELER)('EKSEN A: range %s light\'ta -700, dark\'ta semantik token', (aile) => {
-    expect(varyantSinifi(RANGE_BLOK, aile)).toBe(
+    expect(variantClass(RANGE_BLOK, aile)).toBe(
       `bg-[rgb(var(--${aile}-700))] dark:bg-${aile}`
     )
   })
 
   it.each(AILELER)('EKSEN B: thumb %s kenarlığı light\'ta -700, dark\'ta semantik token', (aile) => {
-    expect(varyantSinifi(THUMB_BLOK, aile)).toBe(
+    expect(variantClass(THUMB_BLOK, aile)).toBe(
       `border-[rgb(var(--${aile}-700))] dark:border-${aile} bg-background`
     )
   })
@@ -295,8 +295,8 @@ describe('#442 kaynak sözleşmesi — slider.tsx', () => {
     // Gereksiz değişiklik yeni regresyon riski. Ölçüm: success A light 3.73 /
     // dark 4.83 · primary A light 3.71 / dark 11.24 — ikisi de ≥3.
     for (const aile of ['primary', 'success'] as const) {
-      expect(varyantSinifi(RANGE_BLOK, aile)).toBe(`bg-${aile}`)
-      expect(varyantSinifi(THUMB_BLOK, aile)).toBe(`border-${aile} bg-background`)
+      expect(variantClass(RANGE_BLOK, aile)).toBe(`bg-${aile}`)
+      expect(variantClass(THUMB_BLOK, aile)).toBe(`border-${aile} bg-background`)
     }
   })
 })
@@ -306,7 +306,7 @@ describe('#442 render sözleşmesi — <Slider />', () => {
     const { container } = render(
       React.createElement(Slider, { trackVariant: aile, rangeVariant: aile })
     )
-    const { track, range } = parcalar(container)
+    const { track, range } = parts(container)
     expect(track).toHaveClass(`bg-${aile}/20`)
     expect(range.className).toContain(`bg-[rgb(var(--${aile}-700))]`)
     expect(range.className).toContain(`dark:bg-${aile}`)
@@ -316,7 +316,7 @@ describe('#442 render sözleşmesi — <Slider />', () => {
 
   it.each(AILELER)('%s: thumb kenarlığı yeni ifadeyle iniyor, dolgusu bg-background kalıyor', (aile) => {
     const { container } = render(React.createElement(Slider, { thumbVariant: aile }))
-    const { thumb } = parcalar(container)
+    const { thumb } = parts(container)
     expect(thumb.className).toContain(`border-[rgb(var(--${aile}-700))]`)
     expect(thumb.className).toContain(`dark:border-${aile}`)
     expect(thumb.className).toContain('bg-background')
@@ -327,7 +327,7 @@ describe('#442 render sözleşmesi — <Slider />', () => {
     // `trackVariant || thumbVariant || "default"` ve `rangeVariant || thumbVariant ||
     // "primary"` düşüşleri değişmedi; en yaygın kullanım bu yoldan geçer.
     const { container } = render(React.createElement(Slider, { thumbVariant: aile }))
-    const { track, range, thumb } = parcalar(container)
+    const { track, range, thumb } = parts(container)
     expect(track).toHaveClass(`bg-${aile}/20`)
     expect(range.className).toContain(`bg-[rgb(var(--${aile}-700))]`)
     expect(thumb.className).toContain(`border-[rgb(var(--${aile}-700))]`)
@@ -337,7 +337,7 @@ describe('#442 render sözleşmesi — <Slider />', () => {
     const { container } = render(
       React.createElement(Slider, { thumbVariant: 'warning', rangeVariant: 'success' })
     )
-    const { range, thumb } = parcalar(container)
+    const { range, thumb } = parts(container)
     expect(range.className).toContain('bg-success')
     expect(range.className).not.toContain('--warning-700')
     // Eksenler bağımsız: tutamaç kendi varyantını korur.
@@ -348,7 +348,7 @@ describe('#442 render sözleşmesi — <Slider />', () => {
     const { container } = render(
       React.createElement(Slider, { rangeVariant: 'primary', thumbVariant: 'primary' })
     )
-    const { range, thumb } = parcalar(container)
+    const { range, thumb } = parts(container)
     expect(range.className).toContain('bg-primary')
     expect(thumb.className).toContain('border-primary')
     expect(range.className).not.toContain('700')
@@ -362,13 +362,13 @@ describe.each(AILELER)('#442 %s — kabul kriteri ≥3:1 (WCAG 1.4.11)', (aile)
     (blok) => {
       // Ölçülen: warning light 4.235 · dark 6.97 (docs kartı 5.77)
       //          error   light 4.950 · dark 4.46 (docs kartı 3.82)
-      const dolgu = rangeRengi(aile, blok)
-      for (const [ad, track] of trackler(aile, blok)) {
-        const oran = rgbKontrast(dolgu, track)
-        expect({ eksen: 'A', zemin: ad, gecti: oran >= 3.0 }).toEqual({
-          eksen: 'A',
-          zemin: ad,
-          gecti: true,
+      const fill = rangeRengi(aile, blok)
+      for (const [name, track] of trackler(aile, blok)) {
+        const oran = rgbKontrast(fill, track)
+        expect({ axis: 'A', background: name, didPass: oran >= 3.0 }).toEqual({
+          axis: 'A',
+          background: name,
+          didPass: true,
         })
       }
     }
@@ -379,13 +379,13 @@ describe.each(AILELER)('#442 %s — kabul kriteri ≥3:1 (WCAG 1.4.11)', (aile)
     (blok) => {
       // Ölçülen: warning light 4.923 · dark 9.45 (docs kartı 8.32)
       //          error   light 6.470 · dark 5.33 (docs kartı 4.69)
-      const kenar = thumbKenarRengi(aile, blok)
-      for (const [ad, zemin] of zeminler(blok)) {
-        const oran = rgbKontrast(kenar, zemin)
-        expect({ eksen: 'B', zemin: ad, gecti: oran >= 3.0 }).toEqual({
-          eksen: 'B',
-          zemin: ad,
-          gecti: true,
+      const border = thumbBorderColor(aile, blok)
+      for (const [name, background] of backgrounds(blok)) {
+        const oran = rgbKontrast(border, background)
+        expect({ axis: 'B', background: name, didPass: oran >= 3.0 }).toEqual({
+          axis: 'B',
+          background: name,
+          didPass: true,
         })
       }
     }
@@ -393,19 +393,19 @@ describe.each(AILELER)('#442 %s — kabul kriteri ≥3:1 (WCAG 1.4.11)', (aile)
 
   it('ESKİ range (semantik token) LIGHT temada başarısızdı — bug’ın belgesi', () => {
     // warning 1.835 · error 2.893. Düzeltmenin GEREKLİLİĞİNİ sabitler.
-    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ĞİŞMEDİ — iki eksende de eski semantik token uygulanıyor', () => {
     // 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(rangeRengi(aile, 'dark')).toEqual(semantikRgb(aile, 'dark'))
-    expect(thumbKenarRengi(aile, 'dark')).toEqual(semantikRgb(aile, 'dark'))
+    expect(rangeRengi(aile, 'dark')).toEqual(semanticRgb(aile, 'dark'))
+    expect(thumbBorderColor(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)
     }
   })
 
@@ -414,29 +414,29 @@ describe.each(AILELER)('#442 %s — kabul kriteri ≥3:1 (WCAG 1.4.11)', (aile)
     // ve `error` tutamacının NEDEN değiştirildiğinin kilidi: kontrastı zaten
     // geçiyordu (3.781), ama range light'ta -700'e inince kenarlığı `border-error`
     // bırakmak iki-tonlu bir görünüm üretirdi.
-    expect(thumbKenarRengi(aile, 'light')).toEqual(rangeRengi(aile, 'light'))
-    expect(thumbKenarRengi(aile, 'dark')).toEqual(rangeRengi(aile, 'dark'))
+    expect(thumbBorderColor(aile, 'light')).toEqual(rangeRengi(aile, 'light'))
+    expect(thumbBorderColor(aile, 'dark')).toEqual(rangeRengi(aile, 'dark'))
   })
 })
 
 describe('#442 eksen B — ailelerin başlangıç durumu FARKLIYDI (kapsam kararının belgesi)', () => {
   it('ESKİ thumb kenarlığı: warning LIGHT\'ta eşiğin ALTINDAYDI (2.133)', () => {
-    const eski = semantikRgb('warning', 'light')
-    for (const [, zemin] of zeminler('light')) {
-      expect(rgbKontrast(eski, zemin)).toBeLessThan(3.0)
+    const old = semanticRgb('warning', 'light')
+    for (const [, background] of backgrounds('light')) {
+      expect(rgbKontrast(old, background)).toBeLessThan(3.0)
     }
   })
 
   it('ESKİ thumb kenarlığı: error LIGHT\'ta zaten geçiyordu (3.781) — değişim gerekçesi tutarlılık', () => {
     // Dürüst kayıt: `error` tutamacı bir kontrast BUG'ı değildi. Aynı ifadeye
     // çekilmesinin sebebi tek-renk tutarlılığı; ölçüm de düşmedi, yükseldi.
-    const eski = semantikRgb('error', 'light')
-    for (const [, zemin] of zeminler('light')) {
-      expect(rgbKontrast(eski, zemin)).toBeGreaterThanOrEqual(3.0)
+    const old = semanticRgb('error', 'light')
+    for (const [, background] of backgrounds('light')) {
+      expect(rgbKontrast(old, background)).toBeGreaterThanOrEqual(3.0)
     }
-    const yeni = thumbKenarRengi('error', 'light')
-    expect(rgbKontrast(yeni, zeminler('light')[0][1])).toBeGreaterThan(
-      rgbKontrast(eski, zeminler('light')[0][1])
+    const yeni = thumbBorderColor('error', 'light')
+    expect(rgbKontrast(yeni, backgrounds('light')[0][1])).toBeGreaterThan(
+      rgbKontrast(old, backgrounds('light')[0][1])
     )
   })
 })
@@ -446,7 +446,7 @@ describe('#442 seçim gerekçesi — reddedilen alternatifler', () => {
     // Issue gövdesinin uyardığı refleks. -700 kademesi dark track'e karşı gerçek
     // docs kartı zemininde eşiğin ALTINDA: warning 2.499 · error 2.232.
     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)
   })
 
@@ -457,22 +457,22 @@ describe('#442 seçim gerekçesi — reddedilen alternatifler', () => {
     // 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) => {
     // Track'i `/10`'a çekmek dolgu↔track'i kazanırken track↔zemin'i harcardı:
     // barın TOPLAM uzunluğu görünmezleşir.
-    const zemin = zeminler('light')[0][1]
-    const sem = semantikRgb(aile, 'light')
-    expect(rgbKontrast(alfaBileske(sem, 0.2, zemin), zemin)).toBeGreaterThan(
-      rgbKontrast(alfaBileske(sem, 0.1, zemin), zemin)
+    const background = backgrounds('light')[0][1]
+    const sem = semanticRgb(aile, 'light')
+    expect(rgbKontrast(alfaBileske(sem, 0.2, background), background)).toBeGreaterThan(
+      rgbKontrast(alfaBileske(sem, 0.1, background), background)
     )
   })
 })