Hustler-Pixelwelt T13: Korrekturen Pult und Keller (Sperre laufender Aktionen, Fokus, Kontrast, Handy-Tippflächen, Pause)
Pult: laufende Anfragen je Eintrags-Id in PultList (laufRef, Brief meldet Beginn/Ende): Brief schließen und denselben Eintrag wieder öffnen sperrt alle Aktionsknöpfe, kein zweites reply/paste/start-build (P1); spätes Ergebnis nennt den Titel (P1b); Original und Entwurf pre-wrap (P3); Überschrift nimmt beim Einhängen den Fokus (M2); „Pult zuklappen“ mit aria-expanded (K4); paused -> hk-steht an der Szene (R3); Brief z-index 9 (R4); Textlinks am Handy 40 px (K7). Keller: Überschrift-Fokus (M2), Reiter-Fokusring innen (M3), Seitenzeile/Punkte/Reiterzahl in Pixelify Sans 13 px (K5), Suchfeld und Akte-Link 40 px am Handy (K7), Ortszeile mit title (W2), paused -> hk-steht (R3), Akte z-index 9 (R4); Arne ohne Eintrag neutral (R5). Tests: Sperre laufender Aktionen, Titel im späten Ergebnis, Fokus, aria-expanded, paused, pre-wrap, z-index, Tippflächen, Reiter-Fokus, Schrift, Kontrast (WCAG) von .hk-zeile-alt/.hk-kl-tag auf Papier und Hover, Arne neutral (alte „Arne schläft ohne Eintrag“-Prüfung ersetzt). Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
This commit is contained in:
ClaudeandClaude Sonnet 5.5 committed
1 parent
ea1485c27c
commit
0924a8d2ae
13 files changed
+597
-70
No files matched your search
@@ -1,6 +1,7 @@
|
||||
import test from 'node:test'
|
||||
import assert from 'node:assert/strict'
|
||||
import { existsSync, readFileSync, statSync } from 'node:fs'
|
||||
import { inflateSync as zlibSync } from 'node:zlib'
|
||||
import path from 'node:path'
|
||||
import { loadModule } from './load.mjs'
|
||||
import {
|
||||
@@ -101,19 +102,104 @@ test('Arne arbeitet nicht: Haus-Figur in der Pose des Status am Pult, Rohrpost,
|
||||
}
|
||||
})
|
||||
|
||||
test('Arne ohne Zustand (Tabelle noch leer, kein Eintrag): er schläft; der Status wechselt mit den Daten der Seite', async () => {
|
||||
// T13 R5 (ersetzt „er schläft“): solange es keinen Eintrag für Arne gibt, weiß die Seite nichts über ihn; er steht neutral am Pult – ohne Zzz (schläft), ohne Kaffeepunkte
|
||||
// (wartet auf Auftrag), ohne Marker und ohne die „nicht“-Pose (nicht angeschlossen). Mit den ersten Daten wechselt er in den echten Zustand.
|
||||
test('Arne ohne Zustand (Tabelle noch leer, kein Eintrag): er steht neutral am Pult, ohne Zzz, Punkte, Marker und „nicht angeschlossen“; der Status wechselt mit den Daten der Seite', async () => {
|
||||
const neutral = (ui, wo) => {
|
||||
assert.equal(sz(ui).props['data-hk-arne'], 'unbekannt', wo)
|
||||
assert.deepEqual(byClass(sz(ui), 'hk-kl-fig').map(classesOf), [['hk-spr', 'hk-kl-fig', 'hk-kl-fig-warten']], wo) // ruhige Haltung, keine Schlaf- oder „nicht“-Pose
|
||||
for (const c of ['hk-kl-zzz', 'hk-kl-punkte', 'hk-alarm', 'hk-kl-fig-schlafen', 'hk-kl-fig-nicht', 'hk-arne-weg', 'hk-arne-bild']) assert.equal(has(ui, c), false, `${wo}: ${c}`)
|
||||
for (const c of RUHENDE) assert.ok(classesOf(byClass(sz(ui), c)[0]).includes('hk-kl-ruht'), `${wo}: ${c} läuft`) // Rohrpost, Stempel und Schublade ruhen
|
||||
}
|
||||
const { ui } = await szene(undefined)
|
||||
try {
|
||||
assert.equal(sz(ui).props['data-hk-arne'], 'leerlauf')
|
||||
assert.ok(has(ui, 'hk-kl-fig-schlafen') && has(ui, 'hk-kl-zzz'))
|
||||
neutral(ui, 'ohne Tabelle')
|
||||
ui.setProps({ workers: { arne: eintrag('arbeitet') } })
|
||||
assert.ok(has(ui, 'hk-arne-weg') && !has(ui, 'hk-kl-fig'))
|
||||
ui.setProps({ workers: { arne: eintrag('fehler') } })
|
||||
assert.ok(!has(ui, 'hk-arne-weg') && has(ui, 'hk-kl-fig-nicht') && has(ui, 'hk-alarm'))
|
||||
ui.setProps({ workers: { arne: eintrag('wartet') } })
|
||||
assert.ok(has(ui, 'hk-kl-fig-warten') && has(ui, 'hk-kl-punkte') && !has(ui, 'hk-alarm'))
|
||||
ui.setProps({ workers: {} })
|
||||
assert.ok(has(ui, 'hk-kl-fig-schlafen'))
|
||||
ui.setProps({ workers: { arne: eintrag('leerlauf') } })
|
||||
assert.ok(has(ui, 'hk-kl-fig-schlafen') && has(ui, 'hk-kl-zzz') && !has(ui, 'hk-kl-punkte')) // ein echter Leerlauf schläft weiterhin
|
||||
ui.setProps({ workers: { arne: eintrag('grau') } })
|
||||
assert.ok(has(ui, 'hk-kl-fig-nicht') && !has(ui, 'hk-kl-zzz') && !has(ui, 'hk-alarm'))
|
||||
// Tabelle leer ({}), Eintrag für Arne fehlt (nur andere Hustler), Eintrag ist keine Tabellenzeile: neutral
|
||||
for (const workers of [{}, { otto: eintrag('arbeitet') }, { arne: null }, { arne: 'arbeitet' }, undefined]) {
|
||||
ui.setProps({ workers })
|
||||
neutral(ui, JSON.stringify(workers))
|
||||
}
|
||||
} finally { ui.end() }
|
||||
})
|
||||
|
||||
// T13 R3: Prop paused (Hustler angehalten) → hk-steht an der Szene; die Regel der Seite (hustler-ui.css) hält darunter alle Animationen an (Arne, Rohrpost, Maus, Licht)
|
||||
test('Szene (T13 R3): paused setzt hk-steht an der Keller-Szene (auch bei arbeitendem Arne), sonst nicht; unbrauchbare Werte gelten als „läuft“', async () => {
|
||||
const klasse = async (initial) => {
|
||||
const { ui } = await szene(undefined)
|
||||
ui.end()
|
||||
const lauf = await start(fakeApi(), initial)
|
||||
try { return classesOf(sz(lauf)).join(' ') } finally { lauf.end() }
|
||||
}
|
||||
assert.equal(await klasse({ paused: true }), 'hk-kl-szene hk-steht')
|
||||
assert.equal(await klasse({ paused: true, workers: { arne: eintrag('arbeitet') } }), 'hk-kl-szene hk-steht')
|
||||
assert.equal(await klasse({ paused: false }), 'hk-kl-szene')
|
||||
assert.equal(await klasse({}), 'hk-kl-szene')
|
||||
for (const unsinn of ['ja', 1, null, {}]) assert.equal(await klasse({ paused: unsinn }), 'hk-kl-szene', String(unsinn))
|
||||
// die Szene ist die Wurzel dieser Animationen und steckt unter .hk-seite (WorkersPage), wo die Regel gilt
|
||||
assert.match(read('src/styles/hustler/hustler-ui.css'), /\.hk-seite \.hk-steht \*[^{]*\{[^}]*animation-play-state:\s*paused\s*!important/)
|
||||
// der Wechsel von „läuft“ zu „steht“ und zurück gilt sofort
|
||||
const lauf = await start(fakeApi(), {})
|
||||
try {
|
||||
assert.equal(classesOf(sz(lauf)).includes('hk-steht'), false)
|
||||
lauf.setProps({ paused: true }); assert.equal(classesOf(sz(lauf)).includes('hk-steht'), true)
|
||||
lauf.setProps({ paused: false }); assert.equal(classesOf(sz(lauf)).includes('hk-steht'), false)
|
||||
} finally { lauf.end() }
|
||||
})
|
||||
|
||||
// T13 M2: Bildschirmwechsel – die Überschrift „Bot-Leads“ nimmt beim Einhängen den Fokus
|
||||
test('Keller (T13 M2): beim Einhängen nimmt die Überschrift „Bot-Leads“ den Fokus (tabIndex -1, preventScroll), nur einmal; ohne Element bricht nichts', async () => {
|
||||
const aufrufe = []
|
||||
const h1 = { focus: (options) => aufrufe.push(options) }
|
||||
globalThis.__fakeRef = (tag) => (tag === 'h1' ? h1 : null)
|
||||
const api = fakeApi()
|
||||
const ui = await start(api, {})
|
||||
try {
|
||||
const titel = nodes(ui.tree(), (n) => n.tag === 'h1')
|
||||
assert.equal(titel.length, 1); assert.equal(titel[0].props.tabIndex, -1); assert.equal(textOf(titel[0]), 'Bot-Leads')
|
||||
assert.deepEqual(aufrufe, [{ preventScroll: true }])
|
||||
// Laden, Raumwechsel, Suche und Akte holen den Fokus nicht wieder an die Überschrift
|
||||
await ui.answer(0, { items: [ITEM], total: 120, pageSize: 50 })
|
||||
await ui.pick(1); await ui.pick(0)
|
||||
await ui.type('Elektro'); ui.fireTimers(); await settle()
|
||||
assert.equal(aufrufe.length, 1)
|
||||
} finally { ui.end(); delete globalThis.__fakeRef }
|
||||
const ohne = await start(fakeApi(), {}) // kein ref: nichts zu fokussieren
|
||||
try { assert.equal(nodes(ohne.tree(), (n) => n.tag === 'h1').length, 1) } finally { ohne.end() }
|
||||
assert.match(cssOhne('src/styles/hustler/hustler-keller-ui.css'), /\.hk-keller \.hk-kl-titel:focus-visible\s*\{[^}]*outline:\s*2px solid/)
|
||||
})
|
||||
|
||||
// T13 K4 (Keller): „Register zuklappen“ sagt, ob das Register offen ist – die Prüfung war schon da, hier wird sie festgehalten
|
||||
test('Keller (T13 K4): „Register zuklappen“ trägt aria-expanded und folgt dem Zustand', async () => {
|
||||
const ui = await start(fakeApi(), {})
|
||||
try {
|
||||
assert.equal(buttons(ui.tree(), 'Register zuklappen')[0].props['aria-expanded'], true)
|
||||
await ui.click('Register zuklappen')
|
||||
assert.equal(buttons(ui.tree(), 'Register aufklappen')[0].props['aria-expanded'], false)
|
||||
} finally { ui.end() }
|
||||
})
|
||||
|
||||
// T13 W2: die Ortszeile kürzt mit „…“, der Browser-Tooltip nennt den vollen Ort samt Datum
|
||||
test('Zeile (T13 W2): die Ortszeile trägt title mit vollem Ort und Funddatum; ohne Ort und Datum kein leeres title', async () => {
|
||||
const ui = await start(fakeApi(), {})
|
||||
try {
|
||||
await ui.answer(0, { items: [{ ...ITEM, city: 'Kaiserslautern-Hohenecken-Am-Lauterstrom', postalCode: '67655' }, { ...ITEM, id: 'p9', city: '', postalCode: '', foundAt: '' }], total: 2 })
|
||||
const zeilen = ui.rows()
|
||||
const klein = (r) => byClass(r, 'hk-klein')[0]
|
||||
assert.equal(klein(zeilen[0]).props.title, '67655 Kaiserslautern-Hohenecken-Am-Lauterstrom · 19.10.2026')
|
||||
assert.equal(klein(zeilen[0]).props.title, textOf(klein(zeilen[0]))) // title = sichtbarer Text, nur ungekürzt
|
||||
// ohne Ort und Datum: botleadRow liefert Platzhalter oder nichts; ein title ist nie leer
|
||||
assert.ok(klein(zeilen[1]).props.title === undefined || klein(zeilen[1]).props.title !== '')
|
||||
assert.equal(klein(zeilen[1]).props.title, textOf(klein(zeilen[1])) === '' ? undefined : textOf(klein(zeilen[1])))
|
||||
} finally { ui.end() }
|
||||
})
|
||||
|
||||
@@ -740,3 +826,124 @@ test('hustler-keller-ui.css: Überschreibungen erzeugter Regeln haben höhere Sp
|
||||
}
|
||||
}
|
||||
})
|
||||
|
||||
// ---------------------------------------------------------------------------------------------------------------
|
||||
// T13 (Endprüfung): Schrift, Tippflächen, Fokusring der Reiter, Stapelreihenfolge, Kontrast
|
||||
|
||||
const eigeneRegeln = (selektor, kontext = '') => ui.regeln.filter((r) => r.kontext === kontext && r.selektor.split(',').map((t) => t.trim()).includes(selektor))
|
||||
const handyRegeln = (selektor) => ui.regeln.filter((r) => /max-width:\s*719px/.test(r.kontext) && r.selektor.split(',').map((t) => t.trim()).includes(selektor))
|
||||
const eigenschaft = (regel, name) => new RegExp(`(?:^|;)\\s*${name}\\s*:\\s*([^;]+)`).exec(regel.koerper)?.[1].trim()
|
||||
const pixel = (wert) => Number.parseFloat(wert)
|
||||
|
||||
test('hustler-keller-ui.css (T13 K5): Seitenzeile, Punkte-Zahl und Reiterzahl stehen in Pixelify Sans ab 13 px, nicht in Press Start 2P mit 8 px', () => {
|
||||
for (const klasse of ['hk-kl-seiten', 'hk-kl-punkte-text', 'hk-kl-reiter-zahl']) {
|
||||
const regeln = ui.regeln.filter((r) => r.selektor.split(',').some((t) => t.trim().endsWith(`.${klasse}`)))
|
||||
assert.ok(regeln.length >= 1, klasse)
|
||||
for (const r of regeln) {
|
||||
const schrift = eigenschaft(r, 'font-family'); const groesse = eigenschaft(r, 'font-size')
|
||||
if (r.kontext === '') { assert.ok(schrift && groesse, `${klasse}: Schrift und Größe stehen in der Grundregel`) }
|
||||
if (schrift) { assert.match(schrift, /^'Pixelify Sans'/, klasse); assert.doesNotMatch(schrift, /Press Start 2P/, klasse) }
|
||||
if (groesse) {
|
||||
assert.ok(pixel(groesse) >= 13, `${klasse}: ${groesse}`)
|
||||
const zeile = eigenschaft(r, 'line-height'); if (zeile) assert.ok(pixel(zeile) >= pixel(groesse), `${klasse}: Zeilenhöhe ${zeile}`)
|
||||
}
|
||||
}
|
||||
}
|
||||
})
|
||||
|
||||
test('hustler-keller-ui.css (T13 K7): am Handy sind Suchfeld und der Textlink der Akte mindestens 40 px hoch (Tippfläche), die Lupe bleibt im Feld mittig', () => {
|
||||
const suche = handyRegeln('.hk-keller input.hk-suche')
|
||||
assert.equal(suche.length, 1); assert.ok(pixel(eigenschaft(suche[0], 'min-height')) >= 40)
|
||||
const link = handyRegeln('.hk-keller .hk-akte-link')
|
||||
assert.equal(link.length, 1); assert.ok(pixel(eigenschaft(link[0], 'min-height')) >= 40)
|
||||
// das Suchfeld ist am Desktop 36 px hoch (erzeugt); min-height gewinnt dort, wo es nötig ist; die Spezifität der Handy-Regel schlägt die erzeugte (input.hk-suche, 2 Klassen + Element)
|
||||
assert.match(cssOhne('src/styles/hustler/keller.css'), /\.hk-keller \.hk-suche\{[^}]*height:36px/)
|
||||
const lupe = handyRegeln('.hk-keller .hk-kl-lupe')
|
||||
assert.equal(lupe.length, 1); assert.equal(pixel(eigenschaft(lupe[0], 'top')), 4) // 40 px Feld: 4 px oben, das 32-px-Symbol sitzt mittig (vorher 2 px bei 36 px)
|
||||
// der Link steht in der Zeile des Textes und zentriert ihn (inline-flex), die 40 px sind also Fläche des Links; „Quelle öffnen“ trägt genau diese Klasse
|
||||
assert.match(cssOhne('src/styles/hustler/keller.css'), /\.hk-keller \.hk-akte-link\{[^}]*display:inline-flex[^}]*align-items:center/)
|
||||
assert.match(read('src/components/workers/keller/Akte.jsx'), /<a className="hk-akte-link" href=\{e\.sourceHref\}/)
|
||||
// am Desktop ändert sich nichts: die Mindesthöhe steht nur im Handy-Block
|
||||
for (const sel of ['.hk-keller input.hk-suche', '.hk-keller .hk-akte-link']) assert.equal(eigeneRegeln(sel).filter((r) => /min-height/.test(r.koerper)).length, 0, sel)
|
||||
})
|
||||
|
||||
// Spezifität grob: Zahl der Klassen und Pseudoklassen (Elementnamen zählen weniger und sind hier nicht nötig)
|
||||
const spezifitaet = (selektor) => (selektor.match(/\.[\w-]+/g) ?? []).length + (selektor.match(/:[\w-]+/g) ?? []).length
|
||||
|
||||
test('hustler-keller-ui.css (T13 M3): Raum-Reiter zeigen den Fokus innen (Umriss nach innen, gelbe Innenkante), auch der aktive; die Regel schlägt die erzeugte', () => {
|
||||
const erzeugt = zerlege(cssOhne('src/styles/hustler/keller.css')).regeln.find((r) => r.selektor === '.hk-keller .hk-reiter:focus-visible')
|
||||
assert.ok(erzeugt)
|
||||
assert.match(erzeugt.koerper, /outline-offset:\s*2px/) // das war der Fehler: außen, am Handy vom wischbaren Reiterstreifen abgeschnitten
|
||||
const normal = eigeneRegeln('.hk-keller .hk-kl-reiter .hk-reiter:focus-visible')
|
||||
const aktiv = eigeneRegeln('.hk-keller .hk-kl-reiter .hk-reiter-an:focus-visible')
|
||||
assert.equal(normal.length, 1); assert.equal(aktiv.length, 1)
|
||||
assert.equal(eigenschaft(normal[0], 'outline-offset'), '-2px'); assert.match(eigenschaft(normal[0], 'outline'), /^2px solid #1a1630$/)
|
||||
// der Ring ist innen (inset) und gelb; der Kasten-Schatten, der den Rand des Reiters bildet, bleibt erhalten (box-shadow ersetzt, nicht ergänzt)
|
||||
assert.match(eigenschaft(normal[0], 'box-shadow'), /inset 0 0 0 4px #ffd25a$/); assert.match(eigenschaft(normal[0], 'box-shadow'), /^0 -2px 0 0 #2b2230, -2px 0 0 0 #2b2230, 2px 0 0 0 #2b2230/)
|
||||
assert.match(eigenschaft(aktiv[0], 'box-shadow'), /inset 0 0 0 4px #ffd25a$/); assert.match(eigenschaft(aktiv[0], 'box-shadow'), /^0 -2px 0 0 #7a2e3a, -2px 0 0 0 #7a2e3a, 2px 0 0 0 #7a2e3a/)
|
||||
// höhere Spezifität als die erzeugten Regeln (auch .hk-reiter-an:hover bleibt unberührt)
|
||||
assert.ok(spezifitaet('.hk-keller .hk-kl-reiter .hk-reiter:focus-visible') > spezifitaet(erzeugt.selektor))
|
||||
assert.ok(spezifitaet('.hk-keller .hk-kl-reiter .hk-reiter-an:focus-visible') > spezifitaet('.hk-keller .hk-reiter-an,.hk-keller .hk-reiter-an:hover'.split(',')[1]))
|
||||
// der Reiter steckt wirklich im Streifen .hk-kl-reiter (RegisterBuch)
|
||||
assert.match(read('src/components/workers/keller/RegisterBuch.jsx'), /className="hk-kl-reiter"[\s\S]*REITER\.map/)
|
||||
})
|
||||
|
||||
test('hustler-keller-ui.css (T13 R4): die Akte liegt unter der Handy-Seitenleiste (z-index 20) und ihrem Hintergrund (15), aber über Szene und Buch', () => {
|
||||
const akte = eigeneRegeln('.hk-keller .hk-kl-akte-ueber')[0]
|
||||
const z = Number(eigenschaft(akte, 'z-index'))
|
||||
assert.ok(z <= 9, `Akte z-index ${z}`)
|
||||
const buch = Number(eigenschaft(eigeneRegeln('.hk-keller .hk-kl-buch')[0], 'z-index'))
|
||||
assert.ok(z > buch, 'über dem Buch')
|
||||
for (const r of ui.regeln) { const w = eigenschaft(r, 'z-index'); if (w) assert.ok(Number(w) <= 9, `${r.selektor}: z-index ${w}`) }
|
||||
})
|
||||
|
||||
// Kontrast nach WCAG 2.x: relative Leuchtdichte, (hell + 0,05) / (dunkel + 0,05)
|
||||
const kanal = (c) => { const v = c / 255; return v <= 0.03928 ? v / 12.92 : ((v + 0.055) / 1.055) ** 2.4 }
|
||||
const leuchtdichte = ([r, g, b]) => 0.2126 * kanal(r) + 0.7152 * kanal(g) + 0.0722 * kanal(b)
|
||||
const kontrast = (a, b) => { const [x, y] = [leuchtdichte(a), leuchtdichte(b)]; return (Math.max(x, y) + 0.05) / (Math.min(x, y) + 0.05) }
|
||||
const hex = (t) => { const m = /#([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})\b/i.exec(t); assert.ok(m, t); return [1, 2, 3].map((i) => Number.parseInt(m[i], 16)) }
|
||||
const mische = (vorn, alpha, hinten) => vorn.map((v, i) => v * alpha + hinten[i] * (1 - alpha)) // Farbe mit Deckkraft über einem Grund
|
||||
|
||||
// RGBA-Pixel einer 8-Bit-PNG (nicht verzahnt; Filter 0–4): das Papier des Buchs liegt als Bild vor (buch.png, „fill“ in der Mitte)
|
||||
function pngPixel(datei, x, y) {
|
||||
const d = readFileSync(path.join(ROOT, datei))
|
||||
const breite = d.readUInt32BE(16); const farbtyp = d[25]; const kanaele = { 2: 3, 6: 4 }[farbtyp]
|
||||
assert.ok(kanaele && d[24] === 8 && d[28] === 0, 'PNG: 8 Bit, RGB oder RGBA, nicht verzahnt')
|
||||
const teile = []
|
||||
for (let i = 8; i < d.length;) { const l = d.readUInt32BE(i); if (d.toString('latin1', i + 4, i + 8) === 'IDAT') teile.push(d.subarray(i + 8, i + 8 + l)); i += 12 + l }
|
||||
const roh = zlibSync(Buffer.concat(teile))
|
||||
const zeile = breite * kanaele
|
||||
let davor = Buffer.alloc(zeile)
|
||||
for (let row = 0; row <= y; row += 1) {
|
||||
const filter = roh[row * (zeile + 1)]; const aktuell = Buffer.from(roh.subarray(row * (zeile + 1) + 1, (row + 1) * (zeile + 1)))
|
||||
for (let i = 0; i < zeile; i += 1) {
|
||||
const a = i >= kanaele ? aktuell[i - kanaele] : 0; const b = davor[i]; const c = i >= kanaele ? davor[i - kanaele] : 0
|
||||
const p = a + b - c; const pa = Math.abs(p - a); const pb = Math.abs(p - b); const pc = Math.abs(p - c)
|
||||
aktuell[i] = (aktuell[i] + [0, a, b, (a + b) >> 1, pa <= pb && pa <= pc ? a : pb <= pc ? b : c][filter]) & 255
|
||||
}
|
||||
davor = aktuell
|
||||
}
|
||||
return [...davor.subarray(x * kanaele, x * kanaele + 3)]
|
||||
}
|
||||
|
||||
test('Kontrast (T13 C5): grau gestellte Einträge („gekürzt“: Zeilentext und Marke) haben auf dem Papier des Buchs und auf der Hover-Tönung mindestens 4,5 : 1', () => {
|
||||
const erzeugt = zerlege(cssOhne('src/styles/hustler/keller.css')).regeln
|
||||
const alt = erzeugt.find((r) => r.selektor === '.hk-keller .hk-zeile-alt')
|
||||
const marke = eigeneRegeln('.hk-keller .hk-kl-tag')[0]
|
||||
const hover = erzeugt.find((r) => r.selektor === '.hk-keller .hk-zeile:hover')
|
||||
assert.ok(alt && marke && hover)
|
||||
const vordergruende = { 'hk-zeile-alt': hex(eigenschaft(alt, 'color')), 'hk-kl-tag': hex(eigenschaft(marke, 'color')) }
|
||||
// Papier: Mitte des Buchs (buch.png, 48 x 48); dieselbe Farbe steht als Papierton im CSS (Reiter „Alle“, großer Punkte-Balken)
|
||||
const papier = pngPixel('src/assets/hustler/keller/ui/buch.png', 24, 24)
|
||||
assert.deepEqual(papier, hex(eigenschaft(erzeugt.find((r) => r.selektor === '.hk-keller .hk-reiter-alle'), 'background')))
|
||||
const m = /rgba\(\s*(\d+),\s*(\d+),\s*(\d+),\s*([\d.]+)\s*\)/.exec(eigenschaft(hover, 'background'))
|
||||
assert.ok(m, 'Hover-Tönung ist rgba(…)')
|
||||
const hoverGrund = mische([Number(m[1]), Number(m[2]), Number(m[3])], Number(m[4]), papier)
|
||||
for (const [name, farbe] of Object.entries(vordergruende)) {
|
||||
const aufPapier = kontrast(farbe, papier); const aufHover = kontrast(farbe, hoverGrund)
|
||||
assert.ok(aufPapier >= 4.5, `${name} auf Papier: ${aufPapier.toFixed(2)} : 1`)
|
||||
assert.ok(aufHover >= 4.5, `${name} auf Hover: ${aufHover.toFixed(2)} : 1`)
|
||||
}
|
||||
// die Rechnung selbst stimmt (Gegenprobe mit bekannten Werten: Schwarz auf Weiß 21 : 1, gleiche Farben 1 : 1)
|
||||
assert.ok(Math.abs(kontrast([0, 0, 0], [255, 255, 255]) - 21) < 1e-9); assert.equal(kontrast([10, 20, 30], [10, 20, 30]), 1)
|
||||
})
|
||||
Reference in new issue
Block a user