DogFatherGit
7351820c55
Er wurde gestern fuer `reaktion.css` gebaut, nachdem `.stufen` dort
zweimal stand und die Stufenleiter der Spenden dadurch das Aussehen
der Chat-Leiste bekam -- drei Stufen nebeneinander, 572 Pixel in
einer 327 Pixel schmalen Spalte, mit der waagerechten Rollleiste auf
Filipes Bildschirmfoto.
Eine Wache, die nur eine Datei ansieht, findet genau die Fehler
dieser einen Datei. Auf alle 36 Stilvorlagen angewandt fand sie
GENAU EINE weitere Stelle.
DER FUND: `.wahl2__eintrag` in gate.css
Zeile 1584 display: block (mit text-overflow: ellipsis)
Zeile 2634 display: flex (fuer Personenbilder, 08.09.2026)
Kein Streit zweier Bauteile, sondern eine spaetere Erweiterung --
und trotzdem ein echter Fehler: `text-overflow: ellipsis` wirkt bei
`display: flex` NICHT auf ein anonymes Flex-Kind. Der Knopf
„… eintragen" in jeder Auswahl des Hauses hat langen Text seither
HART abgeschnitten statt mit „…" gekuerzt.
GEMESSEN -- und nur im Bild zu sehen: `scrollWidth` ist in beiden
Faellen gleich (364 px bei 200 px Breite). Die Zahlen sagten
„kein Unterschied", das Bildschirmfoto zeigte einen. Ein Beleg mehr
dafuer, dass zwei gleiche Zahlen nicht dasselbe Ergebnis bedeuten.
REPARIERT
- Der eigene Eintrag bekommt einen `.wahl2__name`-Span, wie jeder
andere Eintrag auch. Damit kuerzt er wieder mit „…".
- Die zwei Grundregeln sind eine. Wer die erste las, glaubte an
`display: block` -- 1050 Zeilen weiter stand das Gegenteil.
DIE WACHE
923 Grundregeln in 36 Stilvorlagen, keine Klasse zweimal
verschieden gebaut. Gezaehlt wird nur, was sich widersprechen
kann: nicht dieselbe Klasse in einem Zusammenhang (`.saal .pult`),
nicht eine Variante in einer Medienabfrage, nicht
„erst versteckt, dann gezeigt". Sechs Gegenproben, darunter der
echte Fall vom 28.09. und eine Klasse im Kommentar.
GEPRUEFT: css-klassen, freie-namen, suchfeld, tippziele alle EXIT 0.
989 lines
45 KiB
JavaScript
989 lines
45 KiB
JavaScript
/* STEHT DAS CSS AUCH AUF DER SEITE, DIE ES BENUTZT?
|
||
|
||
ENTSTANDEN AUS EINEM ECHTEN FEHLER (05.09.2026).
|
||
|
||
Die Teilnehmerwahl im Kalender benutzte `.wahl__knopf` und
|
||
`.wahl__rolle`. Beide sind sauber definiert -- in dateien.css. Und
|
||
kalender.html bindet dateien.css nicht ein.
|
||
|
||
Ohne `display:inline-flex` und `gap` stehen zwei <span> eben direkt
|
||
nebeneinander. Auf Filipes Bildschirm stand deshalb:
|
||
|
||
DogfatherDogFather VanVanDogFather CigdemManager
|
||
|
||
Vierzig Prüfungen zur Teilnehmerwahl waren grün. Sie prüften, dass
|
||
die richtigen Personen ankommen, dass Fremde weggefiltert werden,
|
||
dass die Sichtbarkeit stimmt -- alles richtig, und alles am Problem
|
||
vorbei. KEINE hat gefragt, ob das Ergebnis auch aussieht wie
|
||
gedacht. Das ist die dritte Sorte Fehler aus der Projektnotiz: nicht
|
||
der übersprungene Test, nicht der grüne, der das Falsche prüft,
|
||
sondern die Frage, die niemand gestellt hat.
|
||
|
||
WAS HIER GEMESSEN WIRD
|
||
|
||
Für jede Workspace-Seite:
|
||
1. Welche Stylesheets bindet sie ein? (rekursiv über @import)
|
||
2. Welche Klassen vergibt sie -- im HTML *und* in ihrem eigenen
|
||
JavaScript (className, classList.add, setAttribute('class')).
|
||
3. Ist jede davon in einem der eingebundenen Stylesheets definiert?
|
||
|
||
WAS BEWUSST NICHT GEMESSEN WIRD
|
||
|
||
Klassen, die es nur zum Anfassen gibt (`js-`), reine Datenanker und
|
||
Klassen aus gemeinsamen Bausteinen, die jede Seite lädt. Und die
|
||
Gegenrichtung ("CSS ohne Benutzer") gehört nicht hierher: Ungenutztes
|
||
CSS ist Ballast, kein Fehler.
|
||
|
||
DRITTER AUSGANG: Findet die Prüfung keine Seiten oder keine Klassen,
|
||
ist das kein "bestanden" -- dann hat sie nichts gemessen und sagt es.
|
||
|
||
GEGENPROBE am Ende: Eine erfundene Klasse muss auffallen, und eine
|
||
echte darf es nicht. */
|
||
|
||
import { readFileSync, readdirSync, existsSync } from "node:fs";
|
||
import { join, dirname, resolve } from "node:path";
|
||
import { fileURLToPath } from "node:url";
|
||
|
||
const HIER = dirname(fileURLToPath(import.meta.url));
|
||
const WURZEL = resolve(HIER, "..");
|
||
const WS = join(WURZEL, "workspace");
|
||
|
||
let fehler = 0;
|
||
const ok = (b, t) => { console.log((b ? " ok " : " FEHL ") + t); if (!b) fehler++; };
|
||
|
||
/* ---------- Welche Stylesheets bindet eine Seite ein? -------------------- */
|
||
|
||
/** Liest ein Stylesheet und folgt seinen @import-Zeilen. */
|
||
function cssMitImporten(pfad, gesehen = new Set()) {
|
||
const echt = resolve(pfad);
|
||
if (gesehen.has(echt) || !existsSync(echt)) return "";
|
||
gesehen.add(echt);
|
||
const text = readFileSync(echt, "utf8");
|
||
let alles = text;
|
||
for (const m of text.matchAll(/@import\s+(?:url\()?["']([^"')]+)["']\)?/g)) {
|
||
alles += "\n" + cssMitImporten(join(dirname(echt), m[1].split("?")[0]), gesehen);
|
||
}
|
||
return alles;
|
||
}
|
||
|
||
/** Alle Klassennamen, die ein CSS-Text definiert. */
|
||
function definierteKlassen(css) {
|
||
const raus = new Set();
|
||
/* Erst Kommentare weg: In diesem Haus stehen lange Erklärungen im
|
||
CSS, und dort kommen Klassennamen als Fließtext vor ("wie
|
||
.wahl__knopf in dateien.css"). Die zählen nicht als Definition --
|
||
sonst würde ausgerechnet der Kommentar, der den Fehler beschreibt,
|
||
ihn verdecken. */
|
||
const ohne = css.replace(/\/\*[\s\S]*?\*\//g, " ");
|
||
for (const m of ohne.matchAll(/\.(-?[A-Za-z_][\w-]*)/g)) raus.add(m[1]);
|
||
return raus;
|
||
}
|
||
|
||
/* ---------- Welche Klassen vergibt eine Seite? --------------------------- */
|
||
|
||
/** Klassen aus dem HTML. */
|
||
function klassenAusHtml(html) {
|
||
const raus = new Set();
|
||
const ohneKommentar = html.replace(/<!--[\s\S]*?-->/g, " ");
|
||
for (const m of ohneKommentar.matchAll(/\bclass\s*=\s*["']([^"']+)["']/g)) {
|
||
for (const k of m[1].split(/\s+/)) if (k) raus.add(k);
|
||
}
|
||
return raus;
|
||
}
|
||
|
||
/** Klassen aus JavaScript. Nur die Formen, die dieses Haus benutzt --
|
||
* ein vollständiger Parser wäre hier Aufwand ohne Ertrag. */
|
||
function klassenAusJs(js) {
|
||
const raus = new Set();
|
||
const ohne = js.replace(/\/\*[\s\S]*?\*\//g, " ");
|
||
const muster = [
|
||
/\.className\s*=\s*['"]([^'"]+)['"]/g,
|
||
/setAttribute\(\s*['"]class['"]\s*,\s*['"]([^'"]+)['"]/g,
|
||
/class\s*=\s*\\?["']([^"'\\]+)/g, // in Template-Literalen
|
||
];
|
||
for (const m of muster) {
|
||
for (const t of ohne.matchAll(m)) {
|
||
for (const stueck of t[1].split(/['",\s]+/)) {
|
||
const k = stueck.trim();
|
||
/* Nur echte Klassennamen -- keine Variablen, keine Ausdrücke. */
|
||
if (k && /^-?[A-Za-z_][\w-]*$/.test(k)) raus.add(k);
|
||
}
|
||
}
|
||
}
|
||
|
||
/* classList.add() BRAUCHT eine eigene Behandlung.
|
||
Der erste Entwurf nahm den ganzen Klammerinhalt und zerlegte ihn
|
||
an Anführungszeichen und Kommas. Bei
|
||
|
||
classList.add(i === 0 ? 'marke__haupt' : 'marke__leise')
|
||
|
||
fiel dabei `i` als angebliche Klasse heraus -- und die Prüfung
|
||
meldete auf sechzehn Seiten eine fehlende Klasse `.i`, die es nie
|
||
gab. Eine Warnung, die falsch ist, ist schlimmer als keine: Sie
|
||
kostet Zeit und wird beim nächsten Mal überlesen.
|
||
Deshalb werden hier NUR die Zeichenketten gelesen, nie der
|
||
Ausdruck drumherum. */
|
||
for (const t of ohne.matchAll(/classList\.(?:add|remove|toggle)\(([^)]*)\)/g)) {
|
||
for (const s of t[1].matchAll(/['"]([^'"]+)['"]/g)) {
|
||
for (const k of s[1].trim().split(/\s+/)) {
|
||
if (k && /^-?[A-Za-z_][\w-]*$/.test(k)) raus.add(k);
|
||
}
|
||
}
|
||
}
|
||
return raus;
|
||
}
|
||
|
||
/** Welche eigenen Skripte bindet die Seite ein? */
|
||
function skripteVon(html) {
|
||
const raus = [];
|
||
for (const m of html.matchAll(/<script[^>]+src\s*=\s*["']([^"']+)["']/g)) {
|
||
const p = m[1].split("?")[0];
|
||
if (/^https?:/.test(p)) continue; // fremde Skripte nicht
|
||
raus.push(join(WS, p.replace(/^\//, "").replace(/^workspace\//, "")));
|
||
}
|
||
return raus;
|
||
}
|
||
|
||
function stylesheetsVon(html) {
|
||
const raus = [];
|
||
for (const m of html.matchAll(/<link[^>]+rel\s*=\s*["']stylesheet["'][^>]*>/g)) {
|
||
const h = /href\s*=\s*["']([^"']+)["']/.exec(m[0]);
|
||
if (!h || /^https?:/.test(h[1])) continue;
|
||
raus.push(join(WS, h[1].split("?")[0].replace(/^\//, "").replace(/^workspace\//, "")));
|
||
}
|
||
return raus;
|
||
}
|
||
|
||
/* Klassen, die absichtlich kein CSS haben. Jede Ausnahme braucht einen
|
||
Grund -- eine Liste ohne Begründung wächst, bis sie alles enthält. */
|
||
const OHNE_CSS = new Set([
|
||
"leise", // Grundstil, steht in gate.css als Elementregel
|
||
]);
|
||
const OHNE_CSS_PRAEFIX = ["js-", "u-"]; // reine Anfasser, nie gestaltet
|
||
|
||
/* =======================================================================
|
||
Die Messung
|
||
======================================================================= */
|
||
console.log("\n=== Ist jede benutzte Klasse auf ihrer Seite auch definiert? ===");
|
||
|
||
const seiten = readdirSync(WS).filter((n) => n.endsWith(".html"));
|
||
/* DIE ANZAHL GEHOERT IN DIE BEDINGUNG, nicht nur in den Meldetext.
|
||
Findet die Prüfung keine Seiten, hat sie nichts gemessen -- und
|
||
"0 von 0 Klassen fehlen" wäre grün und wertlos. */
|
||
ok(seiten.length >= 10, `${seiten.length} Workspace-Seiten gefunden`);
|
||
|
||
/* ALLES CSS DES HAUSES -- für die entscheidende Unterscheidung.
|
||
|
||
Eine Klasse ohne CSS ist zweierlei, und nur eines davon ist ein
|
||
Fehler:
|
||
|
||
(a) NIRGENDS gestaltet. Ein reiner Struktur-Anker wie
|
||
`.k-wdh__ende`, der nur ein <div> benennt. Kein Fehler --
|
||
sonst müsste man jedem Container Deko andichten.
|
||
|
||
(b) Gestaltet, aber in einer Datei, die DIESE SEITE NICHT LÄDT.
|
||
Das ist der Fehler von heute: Jemand hat es gestaltet, es
|
||
sieht im Editor richtig aus, und auf der Seite kommt nichts
|
||
an. Niemandem fällt es auf, weil das CSS ja existiert.
|
||
|
||
Nur (b) schlägt an. */
|
||
const ALLE_CSS = definierteKlassen(
|
||
readdirSync(join(WS, "assets/css")).filter((n) => n.endsWith(".css"))
|
||
.map((n) => readFileSync(join(WS, "assets/css", n), "utf8")).join("\n"));
|
||
|
||
let geprueft = 0;
|
||
const luecken = []; // (b) -- gestaltet, aber nicht hier
|
||
const ungestaltet = []; // (a) -- nur zur Ansicht
|
||
|
||
for (const seite of seiten) {
|
||
const html = readFileSync(join(WS, seite), "utf8");
|
||
|
||
/* DIE SEITE KANN IHRE STILE AUCH SELBST TRAGEN (ergaenzt 19.09.2026).
|
||
|
||
Bis heute las diese Pruefung nur die verlinkten .css-Dateien. Ein
|
||
<style>-Block in der Seite war fuer sie unsichtbar -- und damit
|
||
galt alles, was dort gestaltet ist, als "gestaltet, aber nicht auf
|
||
ihrer Seite".
|
||
|
||
Das traf genau EINE Seite, und zwar eine, die es mit Absicht so
|
||
macht: anruf-probe.html haelt ihre Stile in der Seite, damit sie
|
||
auch dann noch etwas anzeigt, wenn genau das schiefgeht, was sie
|
||
untersucht (eine Stilvorlage aus dem Zwischenspeicher). Die
|
||
Pruefung meldete diese Entscheidung als Fehler -- drei Eintraege
|
||
lang, bei jedem Lauf.
|
||
|
||
Eine Warnung, die immer kommt, ist keine Warnung mehr: Man
|
||
gewoehnt sich an die drei roten Zeilen und uebersieht ab da auch
|
||
die vierte, die echt ist. Deshalb sieht die Pruefung jetzt hin,
|
||
statt die Seite auszunehmen -- eine Ausnahmeliste waere die
|
||
naechste Stelle, die veraltet. */
|
||
const inline = [...html.matchAll(/<style[^>]*>([\s\S]*?)<\/style>/g)]
|
||
.map((m) => m[1]).join("\n");
|
||
const css = stylesheetsVon(html).map((p) => cssMitImporten(p)).join("\n")
|
||
+ "\n" + inline;
|
||
const definiert = definierteKlassen(css);
|
||
|
||
const benutzt = klassenAusHtml(html);
|
||
for (const skript of skripteVon(html)) {
|
||
if (!existsSync(skript)) continue;
|
||
for (const k of klassenAusJs(readFileSync(skript, "utf8"))) benutzt.add(k);
|
||
}
|
||
|
||
for (const k of benutzt) {
|
||
if (OHNE_CSS.has(k)) continue;
|
||
if (OHNE_CSS_PRAEFIX.some((p) => k.startsWith(p))) continue;
|
||
geprueft++;
|
||
if (definiert.has(k)) continue;
|
||
if (ALLE_CSS.has(k)) luecken.push(`${seite}: .${k}`);
|
||
else ungestaltet.push(`${seite}: .${k}`);
|
||
}
|
||
}
|
||
|
||
/* Auch hier die Anzahl in die Bedingung: Wären alle Muster kaputt und
|
||
fänden nichts, stünde sonst "0 Lücken" da -- grün, ohne je eine
|
||
Klasse angesehen zu haben. */
|
||
ok(geprueft > 200, `${geprueft} Klassenverwendungen geprüft`);
|
||
|
||
/* NACH KLASSE GRUPPIERT, nicht nach Seite. Eine fehlende Klasse auf
|
||
sechzehn Seiten ist EIN Fehler, nicht sechzehn -- und wer sechzehn
|
||
fast gleiche Zeilen liest, überliest die siebzehnte, die etwas
|
||
anderes sagt. */
|
||
const nachKlasse = new Map();
|
||
for (const eintrag of luecken) {
|
||
const [seite, klasse] = eintrag.split(": .");
|
||
if (!nachKlasse.has(klasse)) nachKlasse.set(klasse, []);
|
||
nachKlasse.get(klasse).push(seite);
|
||
}
|
||
const bericht = [...nachKlasse.entries()]
|
||
.sort((a, b) => b[1].length - a[1].length)
|
||
.map(([k, s]) => `.${k} — fehlt auf ${s.length} Seite${s.length === 1 ? "" : "n"}`
|
||
+ ` (${s.slice(0, 3).join(", ")}${s.length > 3 ? " …" : ""})`);
|
||
|
||
ok(luecken.length === 0 && geprueft > 200,
|
||
luecken.length
|
||
? `${nachKlasse.size} Klasse${nachKlasse.size === 1 ? "" : "n"} sind gestaltet, aber nicht auf ihrer Seite:`
|
||
+ `\n ${bericht.join("\n ")}`
|
||
: `jede gestaltete Klasse kommt auch auf ihrer Seite an`);
|
||
|
||
/* Kein Fehler, nur zur Kenntnis: Klassen, die es nirgends gibt. Meist
|
||
Struktur-Anker; gelegentlich aber ein Tippfehler, der hier auffällt,
|
||
bevor jemand sich wundert, warum nichts passiert. */
|
||
const nurAnker = new Set(ungestaltet.map((e) => e.split(": .")[1]));
|
||
console.log(` -- ${nurAnker.size} Klassen sind nirgends gestaltet `
|
||
+ `(Struktur-Anker, kein Fehler): ${[...nurAnker].slice(0, 8).join(", ")}`
|
||
+ (nurAnker.size > 8 ? " …" : ""));
|
||
|
||
/* =======================================================================
|
||
Schriftgrößen: nichts unter 11,5 Pixeln
|
||
=======================================================================
|
||
|
||
ZUM ZWEITEN MAL AM SELBEN TAG (06.09.2026). Erst hatten die
|
||
Art-Plaketten des Tagesblicks 10,56 px, dann -- nach der Korrektur --
|
||
die neue "JETZT"-Marke 10,88. Beide Male gemeldet von pruef-handy
|
||
und pruef-grosscheck, beide Male erst nach einem Browserlauf von
|
||
mehreren Minuten.
|
||
|
||
Die Regel steht seit dem 01.09.2026 im Haus: Unter 11,5 px liest auf
|
||
einem Handy niemand mehr, und was dort niemand liest, ist auf dem
|
||
Rechner nur Zierde. Sie wurde bisher nur AM BILD geprüft. Hier wird
|
||
sie an der Quelle geprüft -- in Sekunden statt in Minuten, und
|
||
bevor überhaupt jemand einen Browser startet.
|
||
|
||
WARUM BEIDE PRÜFUNGEN BLEIBEN: Diese hier findet den Wert im
|
||
Stylesheet. Sie kann nicht wissen, ob eine Regel am Ende überhaupt
|
||
greift oder von einer späteren überschrieben wird -- das sieht nur
|
||
der Browser. Die eine ist schnell und ungenau, die andere langsam
|
||
und genau. Zusammen fangen sie beides ab.
|
||
|
||
GERECHNET WIRD MIT 16 px Grundgröße: 0,72 rem = 11,52 px ist gerade
|
||
noch erlaubt, 0,71 rem = 11,36 px nicht mehr. */
|
||
console.log("\n=== Ist irgendeine Schrift zu klein? ===");
|
||
{
|
||
const GRENZE_PX = 11.5;
|
||
const GRUND_PX = 16;
|
||
|
||
let gemessen = 0;
|
||
const zuKlein = [];
|
||
|
||
for (const datei of readdirSync(join(WS, "assets/css")).filter((n) => n.endsWith(".css"))) {
|
||
const text = readFileSync(join(WS, "assets/css", datei), "utf8")
|
||
.replace(/\/\*[\s\S]*?\*\//g, " "); // Kommentare weg
|
||
|
||
for (const treffer of text.matchAll(/font-size:\s*([\d.]+)(rem|em|px)/g)) {
|
||
const wert = Number(treffer[1]);
|
||
const einheit = treffer[2];
|
||
/* `em` hängt von der Umgebung ab und lässt sich hier nicht
|
||
ausrechnen -- solche Stellen werden nicht gezählt, statt sie zu
|
||
raten. Sie sind selten und die Browserprüfung sieht sie. */
|
||
if (einheit === "em") continue;
|
||
const px = einheit === "px" ? wert : wert * GRUND_PX;
|
||
gemessen++;
|
||
if (px < GRENZE_PX) {
|
||
const zeile = text.slice(0, treffer.index).split("\n").length;
|
||
zuKlein.push(`${datei}:${zeile} → ${treffer[1]}${einheit} = ${px.toFixed(2)} px`);
|
||
}
|
||
}
|
||
}
|
||
|
||
/* DIE ANZAHL GEHÖRT IN DIE BEDINGUNG: Fände das Muster gar nichts,
|
||
stünde sonst "0 zu kleine" da -- grün, ohne je eine Größe
|
||
angesehen zu haben. */
|
||
ok(gemessen > 150, `${gemessen} Schriftgrößen im Stylesheet geprüft`);
|
||
|
||
/* EINE GRUNDLINIE, KEIN WUNSCHWERT -- dasselbe Vorgehen wie beim
|
||
Layout-Sprung in pruef-tempo-workspace.
|
||
|
||
Im Bestand stehen 43 solche Stellen. Sie alle zu ändern wäre ein
|
||
Eingriff ins Aussehen von dreizehn Stylesheets, kein Fehlerfix --
|
||
und die Browserprüfung (pruef-handy) beanstandet davon nur die,
|
||
die auf einem Handy WIRKLICH sichtbar sind. Viele greifen dort
|
||
gar nicht oder werden überschrieben.
|
||
|
||
Eine Prüfung, die vom ersten Tag an rot ist, wird weggeklickt --
|
||
und mit ihr die echte Warnung. Sie hält deshalb den heutigen Stand
|
||
fest und schlägt an, sobald es MEHR werden. Genau das hätte heute
|
||
zweimal gegriffen: erst bei den Art-Plaketten (10,56 px), dann bei
|
||
der Jetzt-Marke (10,88) -- beide Male hätte es Minuten statt eines
|
||
Browserlaufs gekostet.
|
||
|
||
Wird der Bestand irgendwann aufgeräumt, gehört die Zahl gesenkt.
|
||
Sie steht hier als Zahl und nicht als Liste, damit niemand eine
|
||
neue Stelle in eine Ausnahmeliste einträgt und sie damit
|
||
stillschweigend erlaubt. */
|
||
/* 43 -> 42 am 14.09.2026: Die Marke auf schmalen Bildschirmen stand
|
||
auf .68rem = 10,88 px (gate.css, Zugangswand von Team Dogi) und ist
|
||
jetzt .72rem. Die Grundlinie wird MITGEZOGEN -- sonst duerfte der
|
||
Fortschritt lautlos wieder verlorengehen, und eine Grundlinie, die
|
||
nur nach oben nachgibt, ist keine. */
|
||
const GRUNDLINIE = 42;
|
||
ok(zuKlein.length <= GRUNDLINIE && gemessen > 150,
|
||
zuKlein.length > GRUNDLINIE
|
||
? `${zuKlein.length} Stellen unter ${GRENZE_PX} px — das sind `
|
||
+ `${zuKlein.length - GRUNDLINIE} MEHR als die Grundlinie ${GRUNDLINIE}. `
|
||
+ `Neu hinzugekommen ist vermutlich eine davon:\n `
|
||
+ zuKlein.slice(-6).join("\n ")
|
||
: `${zuKlein.length} Stellen unter ${GRENZE_PX} px `
|
||
+ `(Grundlinie ${GRUNDLINIE}, nicht mehr geworden)`);
|
||
|
||
if (zuKlein.length && zuKlein.length <= GRUNDLINIE) {
|
||
console.log(` -- davon im Bestand: ${zuKlein.slice(0, 3).join(" · ")} …`
|
||
+ ` — sichtbar sind sie laut pruef-handy nicht, sonst stünden sie dort`);
|
||
}
|
||
|
||
/* GEGENPROBE: Erkennt die Rechnung beide Einheiten -- und lässt sie
|
||
einen erlaubten Wert in Ruhe? Ohne das wäre "0 Treffer" wertlos. */
|
||
const probe = ".a { font-size: .68rem; } .b { font-size: 10px; } .c { font-size: .95rem; }";
|
||
const gefunden = [...probe.matchAll(/font-size:\s*([\d.]+)(rem|em|px)/g)]
|
||
.map(([, w, e]) => (e === "px" ? Number(w) : Number(w) * GRUND_PX))
|
||
.filter((px) => px < GRENZE_PX);
|
||
ok(gefunden.length === 2,
|
||
`Gegenprobe: von drei Größen werden die zwei zu kleinen erkannt `
|
||
+ `(${gefunden.map((p) => p.toFixed(2)).join(", ")} px), die dritte nicht`);
|
||
}
|
||
|
||
/* =======================================================================
|
||
GEGENPROBE — die Messung muss beides können
|
||
======================================================================= */
|
||
console.log("\n=== Gegenprobe ===");
|
||
{
|
||
/* 1. Der echte Fehler von heute, nachgestellt: eine Seite, die eine
|
||
Klasse benutzt, deren CSS in einem nicht eingebundenen
|
||
Stylesheet steht. */
|
||
const definiert = definierteKlassen(".k-dabei__knopf { color: red; }");
|
||
ok(definiert.has("k-dabei__knopf"), "eine definierte Klasse wird erkannt");
|
||
ok(!definiert.has("gibt-es-nicht"), "eine erfundene Klasse wird NICHT erkannt");
|
||
|
||
/* 2. Klassen aus JavaScript werden wirklich mitgelesen -- sonst wäre
|
||
genau der heutige Fall unsichtbar geblieben, denn die Wahl wird
|
||
komplett aus JS gebaut und steht in keinem HTML. */
|
||
const ausJs = klassenAusJs("b.className = 'k-dabei__knopf';\nx.classList.add('offen');");
|
||
ok(ausJs.has("k-dabei__knopf") && ausJs.has("offen"),
|
||
"Klassen aus className und classList.add werden gefunden");
|
||
|
||
/* 3. Ein Klassenname, der nur im KOMMENTAR steht, gilt nicht als
|
||
definiert. Sonst hätte ausgerechnet die Erklärung dieses Fehlers
|
||
ihn zugedeckt. */
|
||
const nurKommentar = definierteKlassen("/* wie .wahl__knopf in dateien.css */\n.echt { color: red; }");
|
||
ok(!nurKommentar.has("wahl__knopf") && nurKommentar.has("echt"),
|
||
"ein Klassenname aus einem Kommentar zählt nicht als Definition");
|
||
|
||
/* 4. Und der Beweis am echten Bestand: Die Wahl im Kalender muss
|
||
JETZT gedeckt sein -- vor der Reparatur wäre genau das rot. */
|
||
const kal = readFileSync(join(WS, "kalender.html"), "utf8");
|
||
const kalCss = definierteKlassen(stylesheetsVon(kal).map((p) => cssMitImporten(p)).join("\n"));
|
||
const noetig = ["k-dabei", "k-dabei__knopf", "k-dabei__zeichen", "k-dabei__name",
|
||
"k-dabei__titel", "k-dabei__liste", "k-dabei__gruppe", "k-dabei__haken", "k-dabei__punkt"];
|
||
const fehlend = noetig.filter((k) => !kalCss.has(k));
|
||
ok(fehlend.length === 0 && noetig.length === 9,
|
||
fehlend.length ? `im Kalender fehlt CSS für: ${fehlend.join(", ")}`
|
||
: `alle ${noetig.length} Klassen der Teilnehmerwahl sind in kalender.css definiert`);
|
||
|
||
/* 5. Und die alten Klassen sind wirklich weg -- nicht nur die neuen
|
||
da. Ein halber Umbau hinterlässt beides. */
|
||
const kalJs = readFileSync(join(WS, "assets/js/kalender.js"), "utf8");
|
||
ok(!/wahl__knopf|wahl__rolle|wahl__name/.test(kalJs.replace(/\/\*[\s\S]*?\*\//g, " ")),
|
||
"die alten .wahl__*-Klassen stehen nicht mehr im Kalender-Skript");
|
||
|
||
/* 6. DIE WICHTIGSTE GEGENPROBE: Unterscheidet die Prüfung die beiden
|
||
Fälle wirklich? Der ganze Wert hängt daran -- ohne sie könnte
|
||
die Bedingung "ALLE_CSS.has(k)" verdreht sein, und die Prüfung
|
||
wäre grün, während sie den echten Fehler durchwinkt.
|
||
|
||
Nachgestellt wird der Fall von heute an einem Miniaturbeispiel:
|
||
Zwei Klassen, beide ohne CSS auf ihrer Seite -- eine davon
|
||
woanders gestaltet, die andere nirgends. */
|
||
const seitenCss = definierteKlassen(".nur-hier { color: red; }");
|
||
const hausCss = definierteKlassen(".nur-hier { color: red; } .woanders { color: blue; }");
|
||
|
||
const fallB = !seitenCss.has("woanders") && hausCss.has("woanders");
|
||
ok(fallB, fallB
|
||
? "gestaltet, aber nicht auf dieser Seite → wird als Fehler erkannt"
|
||
: "MISSLUNGEN — der eigentliche Fehlerfall würde durchgehen");
|
||
|
||
const fallA = !seitenCss.has("blosser-anker") && !hausCss.has("blosser-anker");
|
||
ok(fallA, fallA
|
||
? "nirgends gestaltet → gilt als Struktur-Anker, kein Fehler"
|
||
: "MISSLUNGEN — Struktur-Anker würden fälschlich anschlagen");
|
||
|
||
/* 7. Und der Fehlalarm, den es schon gab, darf nicht zurückkommen:
|
||
`classList.add(i === 0 ? 'a' : 'b')` hatte `i` als Klasse
|
||
gemeldet -- auf sechzehn Seiten. */
|
||
const ausAusdruck = klassenAusJs("x.classList.add(i === 0 ? 'marke__haupt' : 'marke__leise');");
|
||
ok(!ausAusdruck.has("i") && ausAusdruck.has("marke__haupt") && ausAusdruck.has("marke__leise"),
|
||
"aus classList.add(bedingung ? 'a' : 'b') werden beide Klassen gelesen, aber nicht die Variable");
|
||
}
|
||
|
||
/* =======================================================================
|
||
WER kopf.js LAEDT, MUSS AUCH wahl.js LADEN
|
||
|
||
Gefunden am 07.09.2026 beim Durchsehen der Seiten, die bis dahin nur
|
||
GEPRUEFT und nie ANGESEHEN worden waren -- chat.html und
|
||
uebersicht.html luden kopf.js ohne wahl.js.
|
||
|
||
Der Umschalter "Meine Sicht" ist auf allen anderen Seiten ein selbst
|
||
gebautes Bedienelement (`.wahl2`), hinter dem ein unsichtbares
|
||
Systemfeld fuer Vorleseprogramme liegt. Ohne wahl.js faellt kopf.js
|
||
auf dieses Systemfeld zurueck: 92 x 19 Pixel, grauer Kasten, weisse
|
||
Schrift, Systemschriftgroesse -- gemessen, nicht geschaetzt. Auf den
|
||
anderen Seiten misst dasselbe Feld 2 x 2 Pixel bei Deckkraft null,
|
||
weil es dort nur noch der Zugaenglichkeit dient.
|
||
|
||
KAPUTT WAR NICHTS. Der Umschalter funktionierte auf beiden Seiten --
|
||
er sah nur aus wie aus einem anderen Programm. Genau diese Sorte
|
||
Fehler findet keine Pruefung, die auf Fehlermeldungen achtet, und
|
||
auch keine, die Klassennamen zaehlt: Die Klasse `.sicht__feld` ist
|
||
NIRGENDS gestaltet und gilt deshalb zu Recht als Struktur-Anker.
|
||
|
||
Deshalb hier eine Pruefung auf die ABHAENGIGKEIT statt auf die Optik:
|
||
Wer das eine laedt, muss das andere laden -- und zwar vorher. */
|
||
console.log("\n=== Wer kopf.js laedt, laedt auch wahl.js");
|
||
{
|
||
const seitenMitKopf = [];
|
||
for (const seite of readdirSync(WS).filter((f) => f.endsWith(".html"))) {
|
||
const html = readFileSync(join(WS, seite), "utf8");
|
||
const skripte = [...html.matchAll(/<script[^>]+src="assets\/js\/([a-z0-9-]+)\.js/g)]
|
||
.map((m) => m[1]);
|
||
if (!skripte.includes("kopf")) continue;
|
||
seitenMitKopf.push({ seite, skripte });
|
||
}
|
||
ok(seitenMitKopf.length >= 10,
|
||
`${seitenMitKopf.length} Seiten laden kopf.js`);
|
||
|
||
const ohneWahl = seitenMitKopf.filter((s) => !s.skripte.includes("wahl")).map((s) => s.seite);
|
||
ok(ohneWahl.length === 0, ohneWahl.length
|
||
? `ohne wahl.js: ${ohneWahl.join(", ")}`
|
||
: "alle davon laden auch wahl.js");
|
||
|
||
/* UND ZWAR VORHER. kopf.js fragt beim Aufbau nach dem fertigen
|
||
Bedienelement; kommt wahl.js danach, ist es zu spaet. */
|
||
const zuSpaet = seitenMitKopf
|
||
.filter((s) => s.skripte.indexOf("wahl") > s.skripte.indexOf("kopf"))
|
||
.map((s) => s.seite);
|
||
ok(zuSpaet.length === 0, zuSpaet.length
|
||
? `wahl.js steht zu spaet auf: ${zuSpaet.join(", ")}`
|
||
: "und immer VOR kopf.js");
|
||
}
|
||
|
||
/* =======================================================================
|
||
KEIN SKRIPT BAUT SICH SEINE EIGENE ROLLENLISTE
|
||
|
||
Am 07.09.2026 hat Filipe gemeldet, dass „Creator-Profile" bei Spicy
|
||
Media abbricht. Die Ursache war nicht diese Seite: In NEUN Skripten
|
||
stand `const LEITUNG = new Set(['admin', 'manager'])`, und in keinem
|
||
davon `spicy`. profil.js nahm deshalb den Creator-Zweig und lud das
|
||
eigene Profil -- ein Spicy-Zugang ist kein Creator, also 404.
|
||
|
||
Acht der neun sind nicht kaputtgegangen. Sie haben sich still falsch
|
||
verhalten, und das ist der Grund für diese Prüfung: Die Liste steht
|
||
jetzt EINMAL in bereiche.js, und wer sich wieder eine eigene baut,
|
||
bekommt hier einen Fehler statt in vier Wochen eine Fehlermeldung
|
||
bei einer Rolle, an die niemand gedacht hat.
|
||
======================================================================= */
|
||
console.log("\n=== Rollenlisten: eine Quelle, nicht neun");
|
||
{
|
||
const jsOrdner = join(WS, "assets/js");
|
||
const dateien = readdirSync(jsOrdner).filter((n) => n.endsWith(".js"));
|
||
ok(dateien.length >= 15, `${dateien.length} Workspace-Skripte durchgesehen`);
|
||
|
||
/* Gesucht wird eine Rollenliste, die 'admin' enthält und in einer
|
||
Zuweisung steht -- also `new Set([...])` oder `= [...]`. Der
|
||
Kommentar in bereiche.js, der den alten Fehler ZITIERT, darf nicht
|
||
mitzählen: Sonst verdeckt ausgerechnet die Erklärung den Befund. */
|
||
const eigenbau = [];
|
||
for (const n of dateien) {
|
||
const roh = readFileSync(join(jsOrdner, n), "utf8");
|
||
const text = roh.replace(/\/\*[\s\S]*?\*\//g, " ").replace(/\/\/[^\n]*/g, " ");
|
||
for (const m of text.matchAll(/(?:new Set\(\s*)?\[\s*((?:'[a-z]+'\s*,\s*)*'[a-z]+')\s*\]/g)) {
|
||
const rollen = m[1].split(",").map((x) => x.trim().replace(/'/g, ""));
|
||
if (!rollen.includes("admin") || rollen.length < 2) continue;
|
||
/* bereiche.js DARF: dort steht die eine Quelle. Und die Listen an
|
||
den Kacheln selbst sind etwas anderes -- sie sagen, wer eine
|
||
KACHEL sieht, nicht wer zur Leitung gehört. Erkennbar daran,
|
||
dass sie hinter `rollen:` stehen. */
|
||
if (n === "bereiche.js") continue;
|
||
const davor = text.slice(Math.max(0, m.index - 40), m.index);
|
||
if (/rollen\s*:\s*$/.test(davor)) continue;
|
||
eigenbau.push(`${n}: [${rollen.join(", ")}]`);
|
||
}
|
||
}
|
||
/* UND DIESELBE SUCHE FUER ROLLEN-OBJEKTE (07.09.2026).
|
||
|
||
Die Liste oben findet Felder und Mengen. Die Namen der Rollen
|
||
stehen aber als OBJEKT da (`{ admin: 'DogFather', ... }`), und
|
||
genau in dieser Form ist der Fehler ein zweites Mal aufgetreten:
|
||
fuenf Skripte, keines mit 'spicy'. Im Chat stand ueber Cigdems
|
||
Namen woertlich "UNDEFINED".
|
||
|
||
Ein Muster, das nur eine Schreibweise kennt, findet auch nur eine.
|
||
Deshalb hier die zweite. */
|
||
for (const n of dateien) {
|
||
if (n === "bereiche.js" || n === "gate.js") continue; // Quelle bzw. Anmeldeseite
|
||
const roh = readFileSync(join(jsOrdner, n), "utf8");
|
||
const text = roh.replace(/\/\*[\s\S]*?\*\//g, " ").replace(/\/\/[^\n]*/g, " ");
|
||
for (const m of text.matchAll(/\{[^{}]*\badmin\s*:\s*['"][^'"]+['"][^{}]*\}/g)) {
|
||
if (!/\bspicy\s*:/.test(m[0])) eigenbau.push(`${n}: ${m[0].slice(0, 44)}…`);
|
||
}
|
||
}
|
||
|
||
ok(eigenbau.length === 0, eigenbau.length
|
||
? `eigene Rollenliste gefunden: ${eigenbau.slice(0, 4).join(" · ")}`
|
||
: "kein Skript baut sich eine eigene Rollenliste oder ein eigenes Rollen-Objekt");
|
||
|
||
/* GEGENPROBE fuer die Objektform -- sie muss so eines auch finden. */
|
||
const objProbe = "const X = { admin: 'DogFather', manager: 'Manager' };";
|
||
ok([...objProbe.matchAll(/\{[^{}]*\badmin\s*:\s*['"][^'"]+['"][^{}]*\}/g)]
|
||
.some((m) => !/\bspicy\s*:/.test(m[0])),
|
||
"und ein Rollen-Objekt ohne 'spicy' wird auch wirklich gefunden");
|
||
|
||
/* GEGENPROBE: Der Sucher muss so eine Liste auch WIRKLICH finden --
|
||
sonst wäre die Zeile darüber grün, weil das Muster nie greift. */
|
||
const probe = " const LEITUNG = new Set(['admin', 'manager']);";
|
||
const trifft = [...probe.matchAll(/(?:new Set\(\s*)?\[\s*((?:'[a-z]+'\s*,\s*)*'[a-z]+')\s*\]/g)]
|
||
.some((m) => m[1].includes("admin"));
|
||
ok(trifft, "und der Sucher erkennt so eine Liste auch wirklich");
|
||
|
||
/* Und die eine Quelle muss die Rolle enthalten, um die es ging. */
|
||
const quelle = readFileSync(join(jsOrdner, "bereiche.js"), "utf8");
|
||
ok(/LEITUNG\s*=\s*new Set\(\[[^\]]*'spicy'[^\]]*'admin'[^\]]*'manager'[^\]]*\]\)/.test(quelle),
|
||
"bereiche.js führt Spicy Media, DogFather und Manager als Leitung");
|
||
}
|
||
|
||
/* =======================================================================
|
||
DIE SIEBEN KOPIEN DER MODULLISTE MÜSSEN GLEICH SEIN
|
||
|
||
module.css beschreibt die Form aller Module -- Silhouette,
|
||
Kantenlicht, Raster, Handy, Kontrastmodus. Dieselbe Klassenliste
|
||
steht dafür siebenmal in der Datei (im Kontrastmodus dreimal); CSS
|
||
kennt keine Variable für Selektoren.
|
||
|
||
Das ist die verwundbare Stelle: Wer eine Karte hinzufügt und nur
|
||
sechs der sieben Stellen pflegt, bekommt eine Karte MIT Schräge und
|
||
OHNE Kantenlicht -- und niemandem fällt es auf, weil nichts kaputt
|
||
geht. Genau diese Sorte stiller Abweichung fängt hier eine Prüfung
|
||
ab, statt sich auf Sorgfalt zu verlassen.
|
||
======================================================================= */
|
||
console.log("\n=== module.css: die Modulliste steht siebenmal — und überall gleich");
|
||
{
|
||
const pfad = join(WURZEL, "workspace/assets/css/module.css");
|
||
const text = readFileSync(pfad, "utf8");
|
||
|
||
/* Jede Kopie ist mit `/* MODULLISTE */` markiert; gelesen wird die
|
||
Klammer des `:is(...)` direkt danach. */
|
||
const listen = [];
|
||
const marke = /\/\* MODULLISTE \*\/\s*:is\(([^)]*)\)/g;
|
||
for (let t; (t = marke.exec(text)) !== null; ) {
|
||
listen.push(t[1].split(",").map((s) => s.trim()).filter(Boolean));
|
||
}
|
||
|
||
/* Die Anzahl gehört in die BEDINGUNG, nicht nur in den Meldetext:
|
||
Fände die Prüfung keine einzige Liste, wäre "alle gleich" sonst
|
||
trivial erfüllt -- grün, ohne etwas angesehen zu haben. */
|
||
ok(listen.length === 7, `sieben markierte Kopien gefunden (${listen.length})`);
|
||
|
||
const erste = listen[0] || [];
|
||
ok(erste.length >= 30, `die Liste umfasst ${erste.length} Klassen`);
|
||
|
||
const abweichung = listen.findIndex(
|
||
(l) => l.length !== erste.length || l.some((k, i) => k !== erste[i]));
|
||
ok(abweichung === -1, abweichung === -1
|
||
? "alle sieben Kopien sind Zeichen für Zeichen gleich"
|
||
: `Kopie ${abweichung + 1} weicht ab (${listen[abweichung].length} statt ${erste.length} Klassen)`);
|
||
|
||
/* GEGENPROBE: Der Vergleich muss auch NEIN sagen können. Ohne sie
|
||
bewiese die Zeile darüber nur, dass irgendetwas verglichen wurde. */
|
||
const geprobt = [erste, erste.slice(0, -1)];
|
||
const findetEs = geprobt.findIndex(
|
||
(l) => l.length !== erste.length || l.some((k, i) => k !== erste[i]));
|
||
ok(findetEs === 1, "eine künstlich verkürzte Kopie wird erkannt");
|
||
|
||
/* Und die Datei muss auf jeder Seite ZULETZT stehen -- sonst
|
||
überschreiben die Seitendateien die Form wieder, so wie es bis zum
|
||
07.09.2026 auf vier Seiten der Fall war.
|
||
|
||
SEIT DEM 10.09.2026 STEHT EINE DAHINTER: haus.css.
|
||
|
||
Sie entscheidet, ob die Seite das Haus der Agentur oder das von
|
||
Team Dogi traegt -- auf der Modi-Adresse biegt der Server genau
|
||
diesen Dateinamen um. Sie enthaelt ausschliesslich Variablen
|
||
(`:root`), und bei Variablen entscheidet allein die Reihenfolge:
|
||
Steht sie VOR module.css, gewinnt das Agenturhaus, und zwar
|
||
lautlos -- die Seite sieht dann einfach normal aus.
|
||
|
||
Geprueft wird deshalb ab jetzt das PAAR, nicht eine einzelne
|
||
Datei: module.css an vorletzter, haus.css an letzter Stelle.
|
||
Nur "haus.css ist zuletzt" zu pruefen waere zu wenig -- dann
|
||
koennte module.css irgendwo davor stehen und die Seitendateien
|
||
wieder ueberschreiben, also genau der Fehler von damals. */
|
||
let zuletzt = 0, gesamt = 0;
|
||
const schief = [];
|
||
for (const seite of readdirSync(join(WURZEL, "workspace")).filter((f) => f.endsWith(".html"))) {
|
||
if (seite === "index.html" || seite === "crew-index.html") continue; // Waende laden module.css nicht
|
||
const html = readFileSync(join(WURZEL, "workspace", seite), "utf8");
|
||
const bl = [...html.matchAll(/<link[^>]+rel="stylesheet"[^>]*>/g)].map((m) => m[0]);
|
||
if (!bl.some((z) => z.includes("css/module.css"))) continue;
|
||
gesamt++;
|
||
if (bl.length >= 2
|
||
&& bl[bl.length - 1].includes("css/haus.css")
|
||
&& bl[bl.length - 2].includes("css/module.css")) zuletzt++;
|
||
else schief.push(seite);
|
||
}
|
||
ok(gesamt >= 15 && zuletzt === gesamt,
|
||
`module.css und dahinter haus.css auf allen ${gesamt} Seiten (${zuletzt})`
|
||
+ (schief.length ? ` -- schief: ${schief.join(", ")}` : ""));
|
||
|
||
/* GEGENPROBE: Erkennt die Reihenfolge-Pruefung eine falsche
|
||
Reihenfolge ueberhaupt? Zwei erfundene Listen, eine richtig, eine
|
||
vertauscht. Ohne sie waere die Zeile darueber gruen, sobald der
|
||
Selektor nichts mehr findet. */
|
||
const probeGut = ['<link href="css/module.css">', '<link href="css/haus.css">'];
|
||
const probeSchlecht = ['<link href="css/haus.css">', '<link href="css/module.css">'];
|
||
const richtig = (l) => l.length >= 2 && l[l.length - 1].includes("css/haus.css")
|
||
&& l[l.length - 2].includes("css/module.css");
|
||
ok(richtig(probeGut) && !richtig(probeSchlecht),
|
||
"und eine vertauschte Reihenfolge wird als falsch erkannt");
|
||
|
||
/* DIE ZWEITE WAND LAEDT IHR HAUS DIREKT.
|
||
crew-index.html steht nur auf der Modi-Adresse und darf
|
||
crew-haus.css beim Namen nennen -- sie MUSS es sogar: Eine
|
||
Zugangswand, die sich erst nach dem Umbiegen faerbt, waere die
|
||
eine Seite, auf der man das Umfaerben sieht. */
|
||
const wand = readFileSync(join(WURZEL, "workspace", "crew-index.html"), "utf8");
|
||
const wandBl = [...wand.matchAll(/<link[^>]+rel="stylesheet"[^>]*>/g)].map((m) => m[0]);
|
||
ok(wandBl.length >= 2 && wandBl[wandBl.length - 1].includes("css/crew-haus.css"),
|
||
`die zweite Wand laedt ihr Haus zuletzt (${wandBl.length} Stilvorlagen)`);
|
||
}
|
||
|
||
/* =========================================================================
|
||
IST DAS CSS UEBERHAUPT HEIL? (22.09.2026)
|
||
=========================================================================
|
||
|
||
ENTSTANDEN AUS EINEM ECHTEN FEHLER, der zwei Wochen live stand.
|
||
|
||
In start.css fehlten an einer Stelle die zwei Zeichen, die einen
|
||
Kommentar schliessen:
|
||
|
||
...
|
||
der Inhalt darin angeordnet ist.
|
||
=====================================================
|
||
<- hier gehoerte `*` `/` hin
|
||
.kacheln {
|
||
|
||
CSS-Kommentare schachteln NICHT. Der Block lief deshalb weiter bis
|
||
zum naechsten Abschluss -- und der stand mitten in `.kacheln`.
|
||
Verschluckt wurde damit die oeffnende Klammer. Die Fehlerbehebung
|
||
des Browsers hat danach auch noch die FOLGENDE Regel mitgenommen,
|
||
weil sie deren Rumpf als Block einer ungueltigen Auswahl las.
|
||
|
||
Gemessen in Chromium, beide Fassungen nacheinander: 738 statt 740
|
||
Regeln. Sichtbar war es als Kachelreihe mit drei Spalten zu 413 px
|
||
statt fuenf zu 243 px.
|
||
|
||
WARUM ES NIEMANDEM AUFFIEL: Eine aeltere `.kacheln`-Regel weiter
|
||
oben sprang ein. Die Seite sah nicht kaputt aus -- nur anders als
|
||
gemeint. Das ist die gefaehrlichste Sorte: Es gibt nichts zu melden,
|
||
keinen Fehler in der Konsole, keinen roten Haken. Nur eine Seite,
|
||
die etwas anderes zeigt als das, was im Quelltext steht.
|
||
|
||
WAS HIER GEMESSEN WIRD -- und warum gerade das:
|
||
|
||
Auf oberster Ebene einer Stilvorlage darf nur dreierlei stehen: eine
|
||
Auswahl mit ihrem Block, eine At-Regel, und Leerraum. Steht dort
|
||
eine ANGABE (`gap: 12px;`) oder eine schliessende Klammer ohne ihre
|
||
oeffnende, dann ist etwas verschluckt worden -- fast immer ein
|
||
Kommentar ohne Abschluss.
|
||
|
||
Das ist strenger als blosses Klammernzaehlen: Eine Klammernprobe ist
|
||
gruen, solange gleich viele auf- wie zugehen, auch wenn ein
|
||
Kommentar mittendrin einen ganzen Block gefressen hat.
|
||
|
||
Kommentare und Zeichenketten werden dabei genauso ueberlesen, wie
|
||
der Browser sie ueberliest -- sonst schlaegt die Pruefung bei jedem
|
||
`/* ... } ... *' + '/` an, und eine Warnung, die immer kommt, ist
|
||
keine mehr.
|
||
========================================================================= */
|
||
console.log("\n=== Ist das CSS ueberhaupt heil? ===");
|
||
|
||
/** Alle Formfehler einer Stilvorlage. Leeres Feld = in Ordnung. */
|
||
function formfehler(text) {
|
||
const funde = [];
|
||
const zeileVon = (stelle) => text.slice(0, stelle).split("\n").length;
|
||
let i = 0, tiefe = 0, puffer = "", pufferAb = 0;
|
||
|
||
while (i < text.length) {
|
||
const c = text[i];
|
||
|
||
if (c === "/" && text[i + 1] === "*") {
|
||
const auf = i;
|
||
i += 2;
|
||
while (i < text.length && !(text[i] === "*" && text[i + 1] === "/")) i++;
|
||
if (i >= text.length) {
|
||
funde.push({ zeile: zeileVon(auf), was: "ein Kommentar wird nie geschlossen" });
|
||
break;
|
||
}
|
||
i += 2;
|
||
continue;
|
||
}
|
||
if (c === '"' || c === "'") {
|
||
const q = c; i++;
|
||
while (i < text.length && text[i] !== q) { if (text[i] === "\\") i++; i++; }
|
||
i++; continue;
|
||
}
|
||
|
||
if (tiefe === 0) {
|
||
if (c === "{") { tiefe = 1; puffer = ""; pufferAb = i + 1; i++; continue; }
|
||
if (c === ";") {
|
||
/* `@import url(...);` und Geschwister duerfen auf oberster
|
||
Ebene mit einem Strichpunkt enden. Alles andere nicht. */
|
||
if (!puffer.trim().startsWith("@")) {
|
||
funde.push({
|
||
zeile: zeileVon(pufferAb),
|
||
was: "eine Angabe steht ausserhalb jeder Regel",
|
||
beleg: puffer.trim().slice(0, 70).replace(/\s+/g, " "),
|
||
});
|
||
}
|
||
puffer = ""; pufferAb = i + 1; i++; continue;
|
||
}
|
||
if (c === "}") {
|
||
funde.push({ zeile: zeileVon(i), was: "eine schliessende Klammer ohne oeffnende" });
|
||
puffer = ""; pufferAb = i + 1; i++; continue;
|
||
}
|
||
puffer += c; i++; continue;
|
||
}
|
||
|
||
if (c === "{") tiefe++;
|
||
else if (c === "}") tiefe--;
|
||
if (tiefe === 0) { puffer = ""; pufferAb = i + 1; }
|
||
i++;
|
||
}
|
||
|
||
if (tiefe !== 0) {
|
||
funde.push({ zeile: "Ende", was: `${tiefe} Regel(n) werden nie geschlossen` });
|
||
}
|
||
return funde;
|
||
}
|
||
|
||
{
|
||
const css = readdirSync(join(WS, "assets", "css")).filter((n) => n.endsWith(".css"));
|
||
/* DRITTER AUSGANG: Ohne Dateien misst die Pruefung nichts, und "0
|
||
Fehler" waere dann ein gruener Haken fuer gar nichts. */
|
||
ok(css.length > 20, `${css.length} Stilvorlagen gefunden`);
|
||
|
||
const kaputt = [];
|
||
for (const name of css) {
|
||
const funde = formfehler(readFileSync(join(WS, "assets", "css", name), "utf8"));
|
||
for (const f of funde) {
|
||
kaputt.push(`${name}:${f.zeile} — ${f.was}` + (f.beleg ? ` ("${f.beleg}")` : ""));
|
||
}
|
||
}
|
||
ok(kaputt.length === 0 && css.length > 20,
|
||
kaputt.length
|
||
? `${kaputt.length} Stelle(n), an denen CSS still verloren geht:\n `
|
||
+ kaputt.join("\n ")
|
||
: `keine Stilvorlage verliert still eine Regel (${css.length} geprueft)`);
|
||
|
||
/* GEGENPROBEN: Die Pruefung muss beides koennen -- anschlagen und
|
||
schweigen. Der vorletzte Fall ist der echte von start.css,
|
||
Zeichen fuer Zeichen nachgebaut. */
|
||
const proben = [
|
||
["gesundes CSS", ".a{b:c} /* } *" + "/ .d[e=';']{f:g}", false],
|
||
["@import mit Strichpunkt", "@import url(x.css); .a{b:c}", false],
|
||
["Kommentar ohne Abschluss", ".a{b:c} /* geht nie zu", true],
|
||
["Angabe ausserhalb jeder Regel", "gap: 12px; .a{b:c}", true],
|
||
["schliessende Klammer zu viel", ".a{b:c}}", true],
|
||
["Regel ohne Abschluss", ".a{b:c", true],
|
||
["der Fall aus start.css", "/* Titel\n ====\n\n.kacheln {\n /* innen *" + "/\n"
|
||
+ " gap: 12px;\n}\n\n.kachel { color: red; }", true],
|
||
];
|
||
const daneben = proben.filter(([, text, soll]) => (formfehler(text).length > 0) !== soll);
|
||
ok(daneben.length === 0 && proben.length === 7,
|
||
daneben.length
|
||
? `Gegenprobe daneben bei: ${daneben.map((p) => p[0]).join(", ")}`
|
||
: `Gegenprobe: alle ${proben.length} Faelle richtig eingeordnet `
|
||
+ `(darunter der echte aus start.css)`);
|
||
}
|
||
|
||
/* ==== JEDE KLAMMER HAT IHR GEGENSTUECK ==============================
|
||
|
||
Am 28.09.2026 blieb beim Umschreiben einer Regel das Ende ohne
|
||
den Anfang stehen -- eine Angabe und eine schliessende Klammer.
|
||
Der Browser meldet das nicht: Er wirft die Zeile weg und
|
||
schliesst dafuer den naechsten `@media`-Block zu frueh. Alles
|
||
danach galt damit auf JEDER Breite. Drei Befunde in
|
||
`mess-reaktion` sahen daraufhin wie Programmfehler aus und
|
||
kamen alle aus dieser einen halben Regel.
|
||
|
||
Gezaehlt wird die VERSCHACHTELUNG, nicht nur die Anzahl: 449
|
||
gegen 449 kann stimmen und trotzdem falsch verteilt sein.
|
||
Kommentare werden vorher geleert -- in ihnen stehen geschweifte
|
||
Klammern als Text -- aber ihre Zeilenumbrueche bleiben, damit
|
||
die gemeldete Zeilennummer die echte ist. */
|
||
{
|
||
const ordner = join(HIER, "..", "workspace", "assets", "css");
|
||
const dateien = readdirSync(ordner).filter((n) => n.endsWith(".css"));
|
||
const zaehle = (roh) => {
|
||
const text = roh.replace(/\/\*[\s\S]*?\*\//g, (m) => m.replace(/[^\n]/g, " "));
|
||
let tiefe = 0, zeile = 1;
|
||
const zuviel = [];
|
||
for (const c of text) {
|
||
if (c === "\n") zeile += 1;
|
||
else if (c === "{") tiefe += 1;
|
||
else if (c === "}") { tiefe -= 1; if (tiefe < 0) { zuviel.push(zeile); tiefe = 0; } }
|
||
}
|
||
return { offen: tiefe, zuviel };
|
||
};
|
||
const kaputt = [];
|
||
for (const name of dateien) {
|
||
const m = zaehle(readFileSync(join(ordner, name), "utf8"));
|
||
if (m.offen !== 0) kaputt.push(`${name}: ${m.offen} Klammer(n) nie geschlossen`);
|
||
if (m.zuviel.length) {
|
||
kaputt.push(`${name}: schliessende Klammer ohne Anfang in Zeile ${m.zuviel.join(", ")}`);
|
||
}
|
||
}
|
||
ok(dateien.length > 5 && kaputt.length === 0,
|
||
kaputt.length ? kaputt.join(" | ")
|
||
: `alle ${dateien.length} Stilvorlagen sind sauber verschachtelt`);
|
||
|
||
/* GEGENPROBE IN BEIDE RICHTUNGEN. Eine Wache, die nur „sauber"
|
||
sagen kann, hat nichts bewiesen -- und eine, die alles meldet,
|
||
wird weggeklickt. */
|
||
const faellt = (t) => { const m = zaehle(t); return m.offen !== 0 || m.zuviel.length > 0; };
|
||
const proben = [
|
||
["die halbe Regel vom 28.09.", ".a { color: red; }\n background: blue; }\n", true],
|
||
["ein offener @media", "@media (x) {\n .a { color: red; }\n", true],
|
||
["eine Klammer im Kommentar", "/* } */\n.a { color: red; }\n", false],
|
||
["sauberes CSS", "@media (x) {\n .a { color: red; }\n}\n", false],
|
||
];
|
||
const daneben = proben.filter(([, t, soll]) => faellt(t) !== soll).map((p) => p[0]);
|
||
ok(daneben.length === 0,
|
||
daneben.length ? `Gegenprobe daneben bei: ${daneben.join(", ")}`
|
||
: `Gegenprobe: alle ${proben.length} Faelle richtig eingeordnet`);
|
||
}
|
||
|
||
/* ==== ZWEI GRUNDREGELN, EIN NAME, ZWEI BAUARTEN =====================
|
||
|
||
Gebaut am 28.09.2026 fuer `reaktion.css`, wo `.stufen` zweimal
|
||
stand: einmal fuer die Stufenleiter der Spenden (`display: grid`),
|
||
600 Zeilen spaeter fuer die Chat-Leiste (`display: flex`). Die
|
||
spaetere gewinnt -- und die Stufenleiter stellte ihre drei Stufen
|
||
nebeneinander, 572 Pixel in einer 327 Pixel schmalen Spalte, mit
|
||
waagerechter Rollleiste. Auf dem Bildschirmfoto sah das aus wie
|
||
ein Platzproblem.
|
||
|
||
AB JETZT FUER ALLE STILVORLAGEN. Eine Wache, die nur eine Datei
|
||
ansieht, findet genau die Fehler dieser einen Datei -- und der
|
||
zweite Fund lag in gate.css.
|
||
|
||
GEZAEHLT WIRD NUR, WAS SICH WIDERSPRECHEN KANN:
|
||
- Die Auswahl muss GENAU die Klasse sein. `.saal .pult { … }`
|
||
ist dieselbe Klasse in einem Zusammenhang, kein zweites
|
||
Bauteil.
|
||
- Regeln in einer Medienabfrage zaehlen nicht -- sie sind per
|
||
Definition Varianten fuer eine andere Umgebung.
|
||
- `display: none` zaehlt nicht. „Erst versteckt, dann gezeigt"
|
||
ist das haeufigste Paar im Haus; wer es meldet, baut eine
|
||
Warnung, die immer kommt. */
|
||
{
|
||
const ordner = join(HIER, "..", "workspace", "assets", "css");
|
||
const ohneMedien = (t) => t.replace(
|
||
/@media[^{]*\{(?:[^{}]|\{[^{}]*\})*\}/g,
|
||
(m) => m.replace(new RegExp("[^" + String.fromCharCode(10) + "]", "g"), " "));
|
||
const positiv = (w) => w && w !== "none" && !/^none\b/.test(w);
|
||
/* LOOKBEHIND STATT VERBRAUCHEN: Mit `(^|[};])` frisst der erste
|
||
Treffer die Klammer, die der naechste als Anfang braeuchte --
|
||
`.a { … } .a { … }` liefert dann nur EINEN Treffer, und genau
|
||
der Fall, um den es geht, faellt durch. */
|
||
const grundregeln = (roh) => {
|
||
const raus = {};
|
||
const text = ohneMedien(roh.replace(/\/\*[\s\S]*?\*\//g,
|
||
(m) => m.replace(new RegExp("[^" + String.fromCharCode(10) + "]", "g"), " ")));
|
||
for (const m of text.matchAll(
|
||
/(?:^|(?<=[};]))\s*(\.(-?[a-zA-Z_][a-zA-Z0-9_-]*))\s*\{([^{}]*)\}/g)) {
|
||
const w = (m[3].match(/(?:^|[\s;])display\s*:\s*([^;]+)/) || [, ""])[1].trim();
|
||
if (!positiv(w)) continue;
|
||
(raus[m[2]] ||= []).push(w);
|
||
}
|
||
return raus;
|
||
};
|
||
const streitIn = (roh) => Object.entries(grundregeln(roh))
|
||
.filter(([, was]) => new Set(was).size > 1)
|
||
.map(([name, was]) => `${name} (${[...new Set(was)].join(" vs. ")})`);
|
||
|
||
const dateien = readdirSync(ordner).filter((n) => n.endsWith(".css"));
|
||
const funde = [];
|
||
let geprueft = 0;
|
||
for (const name of dateien) {
|
||
const roh = readFileSync(join(ordner, name), "utf8");
|
||
geprueft += Object.keys(grundregeln(roh)).length;
|
||
for (const z of streitIn(roh)) funde.push(`${name}: ${z}`);
|
||
}
|
||
ok(geprueft > 100 && funde.length === 0,
|
||
funde.length ? `Namensstreit: ${funde.join(" | ")}`
|
||
: `${geprueft} Grundregeln in ${dateien.length} Stilvorlagen -- `
|
||
+ "keine Klasse zweimal verschieden gebaut");
|
||
|
||
/* GEGENPROBEN IN BEIDE RICHTUNGEN. */
|
||
const faelle = [
|
||
["der Fall vom 28.09. (zwei Grundregeln, anderes display)",
|
||
".stufen { display: grid; } .stufen { display: flex; }", true],
|
||
["verstecken und zeigen",
|
||
".probe { display: none; } .probe { display: grid; }", false],
|
||
["dieselbe Klasse in einem Zusammenhang",
|
||
".pult { display: grid; } .saal .pult { display: flex; }", false],
|
||
["eine Variante in einer Medienabfrage",
|
||
".paar { display: grid; } @media (pointer: coarse) { .paar { display: flex; } }", false],
|
||
["zweimal dasselbe display",
|
||
".gleich { display: grid; } .gleich { display: grid; }", false],
|
||
["eine Klasse im Kommentar",
|
||
"/* .a { display: flex; } */ .a { display: grid; }", false],
|
||
];
|
||
const daneben = faelle
|
||
.filter(([, text, soll]) => (streitIn(text).length > 0) !== soll)
|
||
.map(([name]) => name);
|
||
ok(daneben.length === 0,
|
||
daneben.length ? `Gegenprobe daneben bei: ${daneben.join(", ")}`
|
||
: `Gegenprobe: alle ${faelle.length} Faelle richtig eingeordnet`);
|
||
}
|
||
|
||
console.log(`\n${fehler === 0 ? "ALLES IN ORDNUNG" : `${fehler} FEHLER`}`);
|
||
process.exit(fehler ? 1 : 0);
|