DogFatherGitandClaude Opus 5
018d02c3b8
VanVan im Support, Meldung #6, zweite Haelfte -- der Rest, der heute frueh ausdruecklich offen stehen blieb: „Bei den Vorlagen laesst sich weder die Frist anpassen noch ‚dauerhaft' einstellen, und eine Anmerkung fehlt auch." EIN ZWEITER KNOPF, NICHT EIN FENSTER FUER ALLE „An alle" verteilt zwoelf Aufgaben mit einem Druck. Haette jedes Uebernehmen jetzt ein Fenster geoeffnet, waere der haeufige Weg langsamer geworden, um den seltenen moeglich zu machen. Neben „Uebernehmen" steht deshalb „Anpassen …" -- an den Creator-Vorlagen und am Katalog, aus derselben Funktion. DAS FENSTER IST DAS DES HAUSES `frageNach` kann seit heute ein DATUM und einen HAKEN, die Anmerkung konnte es als `grund` schon. Ein eigener kleiner Dialog in vorlagenbrett.js waere der zweite im Haus gewesen -- und der, in dem beim naechsten Mal Esc, Fokusfalle oder der Abbruch fehlen. Beide Felder sind standardmaessig aus; fuer die dreissig anderen Aufrufe aendert sich nichts. DREI ENTSCHEIDUNGEN, DIE NICHT NAHELIEGEND WAREN 1. DIE ANMERKUNG WIRD EINE NOTIZ (`aufgaben_notizen`), kein Anhang an der Beschreibung. Sie traegt damit, von wem sie stammt, und die Aufgabe zeigt sie ohnehin an. In die Beschreibung geschrieben waere sie von der Vorlage nicht mehr zu unterscheiden -- und dieselbe Vorlage haette beim naechsten Mal einen anderen Text. 2. EINE DAUERHAFTE AUFGABE BEKOMMT KEINE FRIST, auch wenn eine mitgeschickt wird. Sie waere ab dem naechsten Tag fuer immer ueberfaellig, und eine Warnung, die immer kommt, ist keine mehr. Dieselbe Regel steht seit Langem im Aenderungsweg; haette sie hier gefehlt, gaebe es zwei Antworten auf dieselbe Frage. Im Fenster wird das Datum deshalb GRAU, sobald der Haken sitzt -- ein Datum, das dasteht und nicht gilt, ist schlimmer als keins. 3. „DAUERHAFT" DARF NUR, WER VERTEILEN DARF. Eine dauerhafte Aufgabe laesst sich nicht abhaken (Commit von heute frueh); wer sie sich selbst anlegen koennte, haette etwas, das er nie wieder loswird. Der Haken fehlt deshalb im Fenster eines Creators -- und abgelehnt wird trotzdem am Server, nicht nur ausgeblendet. EIN FUND, DEN DIE PRUEFUNG GEMACHT HAT `Number(tage) || 7` -- die Untergrenze des Datumsfeldes lag dadurch sieben Tage in der Zukunft statt heute, weil Null in JavaScript unwahr ist. Die VORGABE („in 1 Tag") lag damit UNTER der erlaubten Grenze: Wer das Fenster oeffnete und einfach „Uebernehmen" drueckte, bekam eine Absage. `Number.isFinite` fragt, ob eine Zahl da ist, und nicht, ob sie wahr ist -- derselbe Unterschied wie bei `kill -0`. NEBENBEI BEHOBEN: Ein gerades Anfuehrungszeichen in einem deutschen Fehlersatz (gemeldet von pruef-struktur). GEPRUEFT pruef-aufgaben-vorlagen 46 -> 60 ok eigene Frist kommt an (und die Vorlage saehe 5 Tage vor -- die Angabe hat also wirklich gewirkt), Anmerkung wird woertlich zur Notiz mit Namen, ohne Angabe bleibt alles wie bisher, Scout 403 und es entsteht auch nichts, DogFather 200 und KEINE Frist, „morgen" 400, der 45.13. 400, Vergangenheit 400, und als Gegenprobe dieselbe Vorlage ohne Frist 200. Im Browser: der Knopf, das Fenster, die Vorgabe, kein Haken fuer einen Creator, die Aufgabe traegt danach genau die eingetragene Frist samt Notiz -- und Abbrechen legt nichts an. pruef-nachfrage 74 -> 89 ok Datum mit Vorgabe und Untergrenze, Haken 44 px hoch mit 22-px- Kaestchen (nicht ueber die ganze Zeile), Sperre und Gegenprobe, beide Schranken fuer ein zu fruehes Datum einzeln. pruef-struktur 102 · pruef-css-klassen · pruef-modi-katalog 150 · pruef-aufgabenbrett · pruef-vorlagen 24 · pruef-bewerbung-aufgaben 164 · pruef-zuteilung NUR DAS AGENTURHAUS. Vorlagenbrett und Aufgaben liegen unter `/workspace`; am Crew-Haus aendert sich keine Zeile. Co-Authored-By: Claude Opus 5 <[email protected]>
1101 lines
52 KiB
JavaScript
1101 lines
52 KiB
JavaScript
/* =====================================================================
|
||
pruef-nachfrage.mjs — Nichts verschwindet ohne Nachfrage.
|
||
|
||
Filipe, 19.09.2026: „Es darf vor allem keine Stellen geben, an denen
|
||
ein Benutzer etwas falsch machen kann, nur weil die Seite es nicht
|
||
verständlich genug erklärt." Und: „Fehler möglichst verhindern,
|
||
bevor sie entstehen."
|
||
|
||
---------------------------------------------------------------------
|
||
WAS DAS PROBLEM WAR
|
||
|
||
Das Haus hatte die richtige Bauweise — einen <dialog> statt
|
||
`confirm()` — und begründete sie in `aufgaben.html` sogar ausführlich.
|
||
Nur stand sie IN EINER SEITE. Gemessen am 19.09.2026: **30 Stellen**
|
||
in 16 Dateien griffen weiterhin zu `confirm()` oder `prompt()`.
|
||
|
||
Der Unterschied ist nicht Geschmack. `confirm('Wirklich löschen?')`
|
||
stellt die falsche Frage: Es fragt, ob man sicher ist, und nennt
|
||
nicht, WAS passiert, was BLEIBT und ob es ZURÜCK geht. Genau das
|
||
sind die drei Dinge, die man vor einem Löschen wissen will.
|
||
|
||
---------------------------------------------------------------------
|
||
VIER DINGE WERDEN GEPRÜFT
|
||
|
||
1. KEIN NATIVER DIALOG mehr in einer Seiten-Datei. Ausgenommen ist
|
||
allein der Notnagel in `nachfrage.js` selbst — für Browser ohne
|
||
<dialog>. (Ein Verbot ohne diese Ausnahme wäre falsch: Ein
|
||
iPhone vor Safari 15.4 bekäme sonst gar nichts angezeigt.)
|
||
|
||
2. ANGESCHLOSSEN — jede Seite, deren Skripte `frageNach` benutzen,
|
||
lädt auch `nachfrage.js`. Ohne die Datei wäre `frageNach` nicht
|
||
definiert, und aus einer Rückfrage würde ein Absturz: Der Knopf
|
||
täte stillschweigend nichts.
|
||
|
||
ACHTUNG, hier steckte beim Bauen schon eine Falle: Die erste
|
||
Fassung dieser Prüfung zählte `nachfrage.js` SELBST als Nutzer
|
||
(die Datei enthält das Wort natürlich) — damit war jede Seite
|
||
„Nutzer", die Prüfung immer grün und sie bewies nichts. Deshalb
|
||
ist die Datei unten ausdrücklich ausgenommen.
|
||
|
||
3. GESTALTET — `.dialog` wird in einer Datei gestaltet, die JEDE
|
||
Seite lädt. Vorher stand sie in `aufgaben.css`; auf `dateien.html`
|
||
wäre der Dialog ein weißer Systemkasten auf dunkler Seite
|
||
gewesen. Das ist keine Schönheitsfrage: Ein Kasten, der aussieht
|
||
wie eine Browser-Warnung, wird weggeklickt statt gelesen.
|
||
|
||
4. VOLLSTÄNDIG — jeder Aufruf hat einen `titel` und sagt, was
|
||
passiert (`was`). Ein Dialog ohne diese Angabe ist ein
|
||
`confirm()` mit mehr Zeilen Code.
|
||
|
||
Dazu GEGENPROBEN: Jede Prüfung muss beweisen, dass sie auch
|
||
„nicht in Ordnung" sagen kann.
|
||
|
||
AUFRUF: node server/pruef-nachfrage.mjs
|
||
Läuft in unter zwei Sekunden, ohne Server.
|
||
===================================================================== */
|
||
|
||
import { readFileSync, readdirSync } from "node:fs";
|
||
import { join, dirname } from "node:path";
|
||
import { fileURLToPath } from "node:url";
|
||
import { bestaetige, nachfrageText } from "./helfer-nachfrage.mjs";
|
||
|
||
const HIER = dirname(fileURLToPath(import.meta.url));
|
||
const WURZEL = join(HIER, "..");
|
||
const SEITEN_ORDNER = join(WURZEL, "workspace");
|
||
const JS_ORDNER = join(SEITEN_ORDNER, "assets", "js");
|
||
const CSS_ORDNER = join(SEITEN_ORDNER, "assets", "css");
|
||
|
||
/* Die eine Datei, die `confirm`/`prompt` benutzen DARF -- sie ist der
|
||
Notnagel fuer Browser ohne <dialog>. */
|
||
const DER_NOTNAGEL = "nachfrage.js";
|
||
|
||
/** Ein winziges, gueltiges PNG (1x1) -- echte Kopfbytes, damit der
|
||
* Browser wirklich ein Bild bekommt und die Vorschau etwas anzeigen
|
||
* kann. Vorgetaeuschte Bytes ergaeben ein leeres `<img>`, und die
|
||
* Pruefung haette „Vorschau da" gemeldet, ohne eine zu sehen. */
|
||
const PNG_PROBE = Buffer.from(
|
||
"iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk"
|
||
+ "YPhfDwAChwGA60e6kgAAAABJRU5ErkJggg==", "base64");
|
||
|
||
let ok = 0, fehl = 0;
|
||
const pruef = (name, bedingung, zusatz = "") => {
|
||
if (bedingung) { ok++; console.log(` OK ${name}`); }
|
||
else { fehl++; console.log(` FEHL ${name}${zusatz ? "\n " + zusatz : ""}`); }
|
||
};
|
||
|
||
const lies = (p) => readFileSync(p, "utf8");
|
||
const seiten = readdirSync(SEITEN_ORDNER).filter((f) => f.endsWith(".html"));
|
||
const skripte = readdirSync(JS_ORDNER).filter((f) => f.endsWith(".js"));
|
||
|
||
console.log("\n=== Nachfragen: kein nativer Dialog, und keiner ohne Erklärung ===\n");
|
||
|
||
/* ---------------------------------------------------------------------
|
||
1. KEIN NATIVER DIALOG
|
||
------------------------------------------------------------------ */
|
||
|
||
/** Entfernt Kommentare, bevor gesucht wird. Ohne das zaehlt jeder
|
||
* Kommentar, der `confirm()` ERWAEHNT, als Fund -- und davon gibt es
|
||
* in diesem Haus absichtlich mehrere (die Begruendungen). */
|
||
function ohneKommentare(js) {
|
||
return js.replace(/\/\*[\s\S]*?\*\//g, "").replace(/(^|[^:])\/\/.*$/gm, "$1");
|
||
}
|
||
|
||
const nativ = [];
|
||
for (const f of skripte) {
|
||
if (f === DER_NOTNAGEL) continue;
|
||
const code = ohneKommentare(lies(join(JS_ORDNER, f)));
|
||
/* DAS MUSTER HATTE EINE LUECKE, UND ZWAR DIE GROESSTE MOEGLICHE
|
||
(gefunden am 22.09.2026).
|
||
|
||
Vorher stand hier `(?:^|[^.\w])(confirm|prompt)\s*\(`. Das
|
||
`[^.\w]` sollte fremde Methoden ausschliessen -- etwas wie
|
||
`angebot.prompt()` (so heisst die Installations-Aufforderung des
|
||
Browsers) ist kein nativer Dialog und darf nicht als Fund zaehlen.
|
||
|
||
Nur trifft dieser Ausschluss ausgerechnet die HAEUFIGSTE
|
||
Schreibweise: `window.prompt(` hat einen Punkt davor. Die Pruefung
|
||
war damit gruen, waehrend in teamlage.js ZWEI native prompt()
|
||
standen -- einer davon seit Wochen.
|
||
|
||
Genau das Muster, vor dem dieses Haus warnt: eine Pruefung, die
|
||
laeuft, gruen ist und das Falsche prueft. Gefunden hat es nicht
|
||
sie, sondern eine Suche von Hand.
|
||
|
||
Jetzt zwei Faelle statt einem: mit `window.` davor -- oder ganz
|
||
ohne Punkt. Alles andere (`irgendwas.prompt()`) bleibt aussen
|
||
vor, und das ist weiterhin richtig. */
|
||
for (const m of code.matchAll(/(?:^|[^.\w])(?:window\s*\.\s*)?(confirm|prompt)\s*\(/g)) {
|
||
const zeile = code.slice(0, m.index).split("\n").length;
|
||
nativ.push(`${f}:${zeile} → ${m[1]}()`);
|
||
}
|
||
}
|
||
pruef("keine Seite benutzt noch confirm() oder prompt()", nativ.length === 0,
|
||
nativ.slice(0, 8).join("\n "));
|
||
|
||
/* Und der Notnagel ist da -- sonst haetten Browser ohne <dialog> gar
|
||
nichts. Die ZAHL gehoert in die Bedingung, nicht nur in den Text. */
|
||
const notnagel = lies(join(JS_ORDNER, DER_NOTNAGEL));
|
||
pruef("der Notnagel für alte Browser ist vorhanden",
|
||
/HTMLDialogElement/.test(notnagel) && /window\.confirm\(/.test(notnagel));
|
||
|
||
/* ---------------------------------------------------------------------
|
||
2. ANGESCHLOSSEN
|
||
------------------------------------------------------------------ */
|
||
|
||
/** Welche Skripte rufen frageNach auf? OHNE die Datei, die es
|
||
* DEFINIERT -- sonst ist die Antwort immer „alle". */
|
||
const nutzer = new Set();
|
||
/* EIN AUFRUF HINTER EINER `typeof`-ABFRAGE IST KEINE PFLICHT
|
||
(24.09.2026 -- und die Pruefung war aus genau diesem Grund rot,
|
||
ohne dass etwas kaputt war).
|
||
|
||
`installieren.js` liegt auf fast jeder Seite und ruft frageNach
|
||
auf -- aber ausdruecklich nur, wenn es da ist:
|
||
|
||
if (typeof window.frageNach === 'function') { … }
|
||
|
||
Der Kommentar daneben erklaert seit dem 22.09.2026 genau, warum:
|
||
Die Datei laeuft auch auf der Anmeldewand, wo nachfrage.js mit
|
||
Absicht nicht geladen wird. Die Pruefung zaehlte den Aufruf
|
||
trotzdem als "diese Seite fragt nach" -- und weil installieren.js
|
||
ueberall liegt, wurde damit JEDE Seite zur fragenden. Ergebnis:
|
||
fuenf rote Zeilen, kein einziger echter Mangel.
|
||
|
||
EINE PRUEFUNG, DIE IMMER ROT IST, IST KEINE PRUEFUNG MEHR -- genau
|
||
wie eine Warnung, die immer kommt. Ab dem zweiten Mal liest man
|
||
sie weg, und dann auch die echte.
|
||
|
||
Die Unterscheidung ist einfach und haelt: Wer vorher fragt, ob es
|
||
die Funktion gibt, kommt ohne sie aus. Wer sie einfach aufruft,
|
||
braucht sie. */
|
||
const geschuetzt = (text) =>
|
||
/typeof\s+window\.frageNach\s*===?\s*['"]function['"]/.test(text)
|
||
|| /window\.frageNach\s*\?\./.test(text);
|
||
const freiwillig = new Set();
|
||
for (const f of skripte) {
|
||
if (f === DER_NOTNAGEL) continue;
|
||
const text = ohneKommentare(lies(join(JS_ORDNER, f)));
|
||
if (!/\bfrageNach\s*\(/.test(text)) continue;
|
||
if (geschuetzt(text)) { freiwillig.add(f); continue; }
|
||
nutzer.add(f);
|
||
}
|
||
pruef("es gibt überhaupt Seiten, die nachfragen", nutzer.size > 0,
|
||
`gefunden: ${nutzer.size}`);
|
||
/* WAS HIER HERAUSFAELLT, WIRD BENANNT. Ein stilles Aussortieren
|
||
waere die bequeme Art, eine Pruefung gruen zu bekommen -- man
|
||
saehe dann nicht mehr, wie gross die Ausnahme geworden ist. */
|
||
pruef("die geschützten Aufrufe sind benannt und wenige",
|
||
freiwillig.size <= 3,
|
||
`ohne Pflicht zur Datei (typeof-Abfrage davor): ${[...freiwillig].join(", ") || "keine"}`);
|
||
/* GEGENPROBE: Ein UNGESCHUETZTER Aufruf muss weiterhin zaehlen --
|
||
sonst hiesse "alle angeschlossen" nur, dass die Regel niemanden
|
||
mehr erfasst. */
|
||
pruef("Gegenprobe: ein ungeschützter Aufruf zählt weiterhin",
|
||
!geschuetzt("frageNach({ titel: 'x' });")
|
||
&& geschuetzt("if (typeof window.frageNach === 'function') frageNach({});"),
|
||
`${nutzer.size} Dateien rufen ungeschützt auf`);
|
||
|
||
const ohneDatei = [], totesGewicht = [], fragendeSeiten = [];
|
||
let mitNutzung = 0;
|
||
for (const s of seiten) {
|
||
const html = lies(join(SEITEN_ORDNER, s));
|
||
const geladen = [...html.matchAll(/<script src="assets\/js\/([a-z0-9-]+\.js)/g)]
|
||
.map((m) => m[1]);
|
||
/* ZWEI GRUENDE, die Datei zu brauchen (20.09.2026):
|
||
fragen -- oder einen Dialog mit Eingabefeldern haben. Seit die
|
||
Verwurfwache existiert, bewacht `nachfrage.js` jeden solchen
|
||
Dialog von selbst, auch ohne einen einzigen `frageNach`-Aufruf
|
||
in der Seite. Ohne diesen zweiten Grund wuerde eine Seite mit
|
||
einem reinen Formular-Dialog hier als „totes Gewicht" gemeldet --
|
||
und jemand naehme die Datei heraus, die dort gerade arbeitet. */
|
||
const hatDialogMitFeld = [...html.matchAll(/<dialog[^>]*>[\s\S]*?<\/dialog>/g)]
|
||
.some((m) => /<(input|textarea|select)\b/.test(m[0]));
|
||
const kannFragen = geladen.some((g) => nutzer.has(g)) || hatDialogMitFeld;
|
||
const hatDatei = html.includes("assets/js/nachfrage.js");
|
||
if (kannFragen) { mitNutzung++; fragendeSeiten.push(s); if (!hatDatei) ohneDatei.push(s); }
|
||
else if (hatDatei) totesGewicht.push(s);
|
||
}
|
||
pruef("jede Seite, die nachfragt, lädt auch nachfrage.js",
|
||
mitNutzung > 0 && ohneDatei.length === 0,
|
||
`${mitNutzung} Seiten nutzen es, ohne Datei: ${ohneDatei.join(", ") || "keine"}`);
|
||
|
||
/* UND DIE GEGENRICHTUNG. Ohne sie waere „ueberall einbinden" die
|
||
bequeme Antwort -- und die Anmeldewand, die jeder Besucher als
|
||
erste laedt, truege 4,8 KB fuer einen Dialog, den sie nie zeigt.
|
||
Zwei Richtungen, eine Regel: Die Datei liegt genau dort, wo sie
|
||
gebraucht wird. */
|
||
pruef("und keine Seite lädt sie, ohne je nachzufragen",
|
||
totesGewicht.length === 0,
|
||
`unnötig geladen auf: ${totesGewicht.join(", ")}`);
|
||
|
||
/* ---------------------------------------------------------------------
|
||
3. GESTALTET, UND ZWAR ÜBERALL
|
||
------------------------------------------------------------------ */
|
||
|
||
/** In welchen CSS-Dateien wird `.dialog` gestaltet? */
|
||
const dialogCss = readdirSync(CSS_ORDNER).filter((f) => f.endsWith(".css"))
|
||
.filter((f) => /^\.dialog[\s,{:]/m.test(lies(join(CSS_ORDNER, f))));
|
||
|
||
/** Und welche davon laedt jede Seite, DIE NACHFRAGEN KANN? Abgeleitet,
|
||
* nicht behauptet -- eine Liste „module.css laedt ueberall" waere genau
|
||
* die abgeschriebene Liste, vor der die Hausregeln warnen.
|
||
*
|
||
* Gemessen wird gegen die fragenden Seiten, nicht gegen alle: Die zwei
|
||
* Anmeldewaende zeigen nie einen Dialog. Von ihnen die Dialog-
|
||
* Gestaltung zu verlangen hiesse, 12 KB auf die Seite zu legen, die
|
||
* jeder Besucher als erste laedt -- fuer nichts. */
|
||
const ueberall = new Set(dialogCss);
|
||
for (const s of fragendeSeiten) {
|
||
const html = lies(join(SEITEN_ORDNER, s));
|
||
const css = new Set([...html.matchAll(/href="assets\/css\/([a-z0-9-]+\.css)/g)]
|
||
.map((m) => m[1]));
|
||
for (const d of [...ueberall]) if (!css.has(d)) ueberall.delete(d);
|
||
}
|
||
pruef(".dialog wird dort gestaltet, wo jede fragende Seite es lädt",
|
||
ueberall.size > 0 && fragendeSeiten.length > 0,
|
||
`.dialog steht in: ${dialogCss.join(", ")} — von allen `
|
||
+ `${fragendeSeiten.length} fragenden Seiten geladen: `
|
||
+ `${[...ueberall].join(", ") || "KEINE"}`);
|
||
|
||
/* Die zwei eigenen Bauteile des Nachfrage-Dialogs gehoeren in dieselbe
|
||
Datei -- sonst waere der wichtigste Satz ("nicht rueckgaengig")
|
||
ungestaltet. */
|
||
const gemeinsam = [...ueberall][0];
|
||
const gCss = gemeinsam ? lies(join(CSS_ORDNER, gemeinsam)) : "";
|
||
pruef("auch die Warnzeile und die Fehlerzeile sind dort gestaltet",
|
||
/\.nachfrage__endgueltig/.test(gCss) && /\.nachfrage__fehler/.test(gCss));
|
||
|
||
/* Und sie traegt ihre Aussage nicht nur ueber Farbe. */
|
||
pruef("die Warnzeile hat ein Zeichen, nicht nur eine Farbe",
|
||
/\.nachfrage__endgueltig::before\s*{[^}]*content/.test(gCss),
|
||
"Farbe allein trägt keine Aussage — Rot-Grün-Schwäche, Kontrastmodus");
|
||
|
||
/* ---------------------------------------------------------------------
|
||
4. VOLLSTÄNDIG: jeder Aufruf sagt, was passiert
|
||
------------------------------------------------------------------ */
|
||
|
||
/** Schneidet den Objektliteral-Teil eines frageNach-Aufrufs heraus,
|
||
* klammergenau. Ein Muster „bis zur naechsten }" wuerde bei jedem
|
||
* verschachtelten Ausdruck danebengreifen. */
|
||
function aufrufe(js) {
|
||
const out = [];
|
||
for (const m of js.matchAll(/frageNach\s*\(\s*{/g)) {
|
||
let i = m.index + m[0].length - 1, tiefe = 0, j = i;
|
||
for (; j < js.length; j++) {
|
||
if (js[j] === "{") tiefe++;
|
||
else if (js[j] === "}") { tiefe--; if (tiefe === 0) { j++; break; } }
|
||
}
|
||
out.push(js.slice(i, j));
|
||
}
|
||
return out;
|
||
}
|
||
|
||
let gezaehlt = 0;
|
||
const ohneTitel = [], ohneWas = [];
|
||
for (const f of skripte) {
|
||
if (f === DER_NOTNAGEL) continue;
|
||
const code = ohneKommentare(lies(join(JS_ORDNER, f)));
|
||
for (const a of aufrufe(code)) {
|
||
gezaehlt++;
|
||
/* AUCH DIE KURZSCHREIBWEISE ZAEHLT (24.09.2026).
|
||
Gesucht wurde nur `titel:`. In installieren.js steht aber
|
||
`frageNach({ titel, was: weg, … })` -- die Kurzform, die den
|
||
Titel aus einer gleichnamigen Variablen nimmt. Gueltiges JS,
|
||
gesetzter Titel, und trotzdem gemeldet. Eine Pruefung, die eine
|
||
richtige Schreibweise bemaengelt, bringt einem bei, ihre
|
||
Meldungen zu ignorieren. */
|
||
if (!/\btitel\s*[:,}]/.test(a)) ohneTitel.push(f);
|
||
if (!/\bwas\s*:/.test(a)) ohneWas.push(f);
|
||
}
|
||
}
|
||
/* DIE ZAHL GEHOERT IN DIE BEDINGUNG: Bei null Aufrufen waere
|
||
„alle haben einen Titel" trivialerweise wahr. */
|
||
pruef("jeder Aufruf hat einen Titel", gezaehlt > 0 && ohneTitel.length === 0,
|
||
`${gezaehlt} Aufrufe geprüft, ohne Titel: ${ohneTitel.join(", ") || "keiner"}`);
|
||
pruef("jeder Aufruf sagt, WAS passiert", gezaehlt > 0 && ohneWas.length === 0,
|
||
`ohne „was": ${ohneWas.join(", ") || "keiner"}`);
|
||
|
||
/* Und die gefaehrlichste Handlung im Haus -- eine Person loeschen --
|
||
verlangt das Abtippen des Namens. Das ist keine Schikane: Der
|
||
Loeschknopf sitzt neben dem Sperrknopf. */
|
||
pruef("eine Person löschen verlangt den Namen abgetippt",
|
||
/tippen:\s*v\.person\.name/.test(lies(join(JS_ORDNER, "personen.js"))));
|
||
|
||
/* ---------------------------------------------------------------------
|
||
DIE VERWURFWACHE — beide Schliesswege, und kein Dauerfeuer
|
||
------------------------------------------------------------------ */
|
||
const wache = notnagel;
|
||
pruef("die Verwurfwache faengt Esc ab (das `cancel`-Ereignis)",
|
||
/addEventListener\('cancel'/.test(wache),
|
||
"ohne sie liefe Esc durch -- der Browser ruft close() dabei NICHT auf");
|
||
pruef("und sie faengt auch close() ab (die Abbrechen-Knoepfe)",
|
||
/dlg\.close = function/.test(wache),
|
||
"ohne sie liefe der Knopf durch -- er loest kein `cancel` aus");
|
||
pruef("sie ersetzt close() nur AM DIALOG, nicht am Prototyp",
|
||
!/HTMLDialogElement\.prototype\.close\s*=/.test(wache),
|
||
"ein globaler Eingriff traefe den Nachfrage-Dialog selbst -- der ginge nie mehr zu");
|
||
pruef("sie fragt nur bei wirklicher Aenderung",
|
||
/const geaendert = \(\) =>/.test(wache) && /if \(!geaendert\(\)\)/.test(wache),
|
||
"eine Warnung, die immer kommt, ist keine Warnung mehr");
|
||
pruef("sie bewacht sich nicht selbst",
|
||
/dialog:not\(\.nachfrage\)/.test(wache),
|
||
"sonst fragte der Nachfrage-Dialog beim Schliessen nach sich selbst");
|
||
|
||
/* Und die Speicherwege sagen ihr Bescheid -- sonst fragte sie nach
|
||
jedem erfolgreichen Speichern. */
|
||
let speicherwege = 0;
|
||
for (const f of skripte) {
|
||
if (f === DER_NOTNAGEL) continue;
|
||
speicherwege += [...ohneKommentare(lies(join(JS_ORDNER, f)))
|
||
.matchAll(/\.vergessen\?\.\(\)/g)].length;
|
||
}
|
||
pruef("die Speicherwege melden der Wache, dass nichts mehr zu retten ist",
|
||
speicherwege >= 8, `${speicherwege} Stellen rufen vergessen()`);
|
||
|
||
/* ---------------------------------------------------------------------
|
||
DIE GEGENPROBEN — jede muss anschlagen
|
||
------------------------------------------------------------------ */
|
||
console.log("\n --- Gegenproben (jede MUSS anschlagen) ---");
|
||
|
||
/* DIE GEGENPROBE PRUEFT JETZT BEIDE SCHREIBWEISEN. Haette sie das
|
||
vorher getan, waere die Luecke im Muster am selben Tag aufgefallen,
|
||
an dem es geschrieben wurde. */
|
||
pruef("Gegenprobe: ein erfundenes window.prompt() würde gefunden",
|
||
/(?:^|[^.\w])(?:window\s*\.\s*)?(confirm|prompt)\s*\(/.test(
|
||
"const g = window.prompt('Warum nicht?');"));
|
||
pruef("Gegenprobe: eine fremde Methode NICHT (angebot.prompt())",
|
||
!/(?:^|[^.\w])(?:window\s*\.\s*)?(confirm|prompt)\s*\(/.test(
|
||
"angebot.prompt();"));
|
||
pruef("Gegenprobe: ein erfundenes confirm() würde gefunden",
|
||
/(?:^|[^.\w])(confirm|prompt)\s*\(/.test(
|
||
ohneKommentare("function x(){ if (!confirm('weg?')) return; }")));
|
||
|
||
pruef("Gegenprobe: ein confirm() im KOMMENTAR wird NICHT gemeldet",
|
||
!/(?:^|[^.\w])(confirm|prompt)\s*\(/.test(
|
||
ohneKommentare("/* frueher stand hier confirm('weg?') */")));
|
||
|
||
pruef("Gegenprobe: nachfrage.js selbst zählt nicht als Nutzer",
|
||
!nutzer.has(DER_NOTNAGEL),
|
||
'sonst wäre jede Seite trivialerweise Nutzer und die Prüfung grün ohne Inhalt');
|
||
|
||
pruef("Gegenprobe: die Gestaltung-Prüfung kann auch NEIN sagen",
|
||
(() => {
|
||
/* Eine erfundene Seite, die nachfragt, aber die Datei nicht laedt:
|
||
Die Schnittmenge muss dadurch leer werden. */
|
||
const probe = new Set(dialogCss);
|
||
for (const d of [...probe]) if (!new Set(["gibt-es-nicht.css"]).has(d)) probe.delete(d);
|
||
return probe.size === 0;
|
||
})());
|
||
|
||
pruef("Gegenprobe: ein Aufruf ohne Titel würde auffallen",
|
||
aufrufe("frageNach({ was: 'x' })").length === 1
|
||
&& !/\btitel\s*:/.test(aufrufe("frageNach({ was: 'x' })")[0]));
|
||
|
||
pruef("Gegenprobe: der Klammerzähler findet das Ende auch bei Verschachtelung",
|
||
aufrufe("frageNach({ titel: f({a:1}), was: 'x' }) ; danach")[0]
|
||
=== "{ titel: f({a:1}), was: 'x' }");
|
||
|
||
/* =====================================================================
|
||
UND JETZT AM ECHTEN BILDSCHIRM
|
||
|
||
Alles oben ist Textsuche. Sie beweist, dass der Aufruf dasteht --
|
||
nicht, dass der Dialog aufgeht, dass "Doch nicht" wirklich nichts
|
||
tut und dass das Abtippen wirklich sperrt.
|
||
|
||
Geprüft wird ausgerechnet der gefährlichste Handgriff im Haus: eine
|
||
Person löschen. `pruef-personen-loeschen` gibt es zwar, aber sie
|
||
kennt nur die Schnittstelle -- kein Browser, kein Knopf, kein
|
||
Dialog. Der Weg, den ein Mensch geht, war nie geprüft.
|
||
===================================================================== */
|
||
if (process.env.OHNE_BROWSER === "ja") {
|
||
console.log("\n (Browserteil übersprungen — OHNE_BROWSER=ja)");
|
||
} else {
|
||
const { mkdtempSync, rmSync } = await import("node:fs");
|
||
const { tmpdir } = await import("node:os");
|
||
const { eigenerPort } = await import("./helfer-port.mjs");
|
||
const { notbremse } = await import("./helfer-notbremse.mjs");
|
||
|
||
const ordner = mkdtempSync(join(tmpdir(), "ws-nachfrage-"));
|
||
process.env.WORKSPACE_DB = join(ordner, "workspace.db");
|
||
const PORT = await eigenerPort(import.meta, "die Nachfragepruefung");
|
||
process.env.PORT = String(PORT);
|
||
process.env.SITE_ACCESS_SECRET = "lokaler-test";
|
||
process.env.SITE_PUBLIC_LAUNCH_AT = "2020-01-01T00:00:00+01:00";
|
||
|
||
const express = (await import("express")).default;
|
||
const ec = express.response.cookie;
|
||
express.response.cookie = function (n, w, o) {
|
||
return ec.call(this, n, w, { ...(o || {}), secure: false });
|
||
};
|
||
await import("./index.js");
|
||
notbremse(240_000, "pruef-nachfrage");
|
||
await new Promise((r) => setTimeout(r, 1000));
|
||
const BASIS = `http://127.0.0.1:${PORT}`;
|
||
|
||
const { DatabaseSync } = await import("node:sqlite");
|
||
const { scryptSync, randomBytes } = await import("node:crypto");
|
||
await fetch(BASIS + "/workspace/api/anmelden", {
|
||
method: "POST", headers: { "Content-Type": "application/json" },
|
||
body: JSON.stringify({ rolle: "admin", code: "x" }) }).catch(() => {});
|
||
for (let i = 0; i < 60; i++) {
|
||
try {
|
||
const pb = new DatabaseSync(process.env.WORKSPACE_DB);
|
||
try { pb.prepare("SELECT 1 FROM personen LIMIT 1").get(); break; } finally { pb.close(); }
|
||
} catch { await new Promise((r) => setTimeout(r, 250)); }
|
||
}
|
||
const db = new DatabaseSync(process.env.WORKSPACE_DB);
|
||
const jetzt = new Date().toISOString();
|
||
const anlegen = (name, rolle, code) => {
|
||
const salt = randomBytes(16).toString("hex");
|
||
const h = scryptSync(code, salt, 64,
|
||
{ N: 32768, r: 8, p: 1, maxmem: 96 * 1024 * 1024 }).toString("hex");
|
||
db.prepare("INSERT INTO personen (name, rolle, code_hash, code_salt, code_n, aktiv, erstellt)"
|
||
+ " VALUES (?,?,?,?,?,1,?)").run(name, rolle, h, salt, 32768, jetzt);
|
||
};
|
||
anlegen("Filipe", "admin", "CODE-DOGI-0001");
|
||
anlegen("Testolina", "creator", "CODE-CREA-0001");
|
||
db.close();
|
||
|
||
const pw = await import("file:///C:/Users/qciga/Documents/Obelix/Analyse/node_modules/playwright/index.mjs");
|
||
const browser = await pw.chromium.launch();
|
||
const ctx = await browser.newContext({ viewport: { width: 1280, height: 900 } });
|
||
const seite = await ctx.newPage();
|
||
const abstuerze = [];
|
||
seite.on("pageerror", (f) => abstuerze.push(f.message));
|
||
|
||
await seite.goto(BASIS + "/workspace/", { waitUntil: "networkidle" });
|
||
await seite.click('.rolle[data-rolle="admin"]');
|
||
await seite.fill("#code", "CODE-DOGI-0001");
|
||
await seite.click("button[type=submit]");
|
||
await seite.waitForURL("**/start.html", { timeout: 25000 });
|
||
await seite.goto(BASIS + "/workspace/personen.html", { waitUntil: "networkidle" });
|
||
await seite.waitForTimeout(900);
|
||
|
||
console.log("\n --- Am echten Bildschirm: eine Person löschen ---");
|
||
|
||
const wieViele = () => seite.evaluate(() =>
|
||
[...document.querySelectorAll(".person")].length);
|
||
/* DEN ABSCHNITT AUFKLAPPEN. Die Rollen-Abschnitte sind
|
||
standardmäßig ZU -- nur der eigene ist offen. Das ist so gewollt
|
||
(eine Liste mit fünf offenen Abschnitten ist unlesbar), und eine
|
||
Prüfung, die das nicht weiß, misst eine leere Liste und hält das
|
||
für einen Befund. Genau das ist beim Bauen passiert. */
|
||
await seite.waitForSelector('.gruppe[data-rolle="creator"] .gruppe__kopf',
|
||
{ timeout: 15_000 });
|
||
await seite.click('.gruppe[data-rolle="creator"] .gruppe__kopf');
|
||
await seite.waitForFunction(
|
||
() => document.querySelectorAll(".person").length >= 2,
|
||
{ timeout: 15_000 }).catch(() => {});
|
||
const vorher = await wieViele();
|
||
const namen2 = await seite.evaluate(() =>
|
||
[...document.querySelectorAll(".person")]
|
||
.map((e) => e.textContent.trim().slice(0, 30)).join(" | "));
|
||
pruef("die Liste steht da", vorher >= 2, `${vorher} Personen: ${namen2}`);
|
||
|
||
const loeschKnopf = seite.locator(".person", { hasText: "Testolina" })
|
||
.locator("button", { hasText: "Löschen" }).first();
|
||
await loeschKnopf.click();
|
||
|
||
let dialogDa = true;
|
||
try { await seite.waitForSelector("dialog.nachfrage[open]", { timeout: 4000 }); }
|
||
catch { dialogDa = false; }
|
||
pruef("der Dialog geht auf", dialogDa);
|
||
|
||
if (dialogDa) {
|
||
const inhalt = await nachfrageText(seite);
|
||
pruef("er nennt den Namen im Titel", /Testolina/.test(inhalt.titel), inhalt.titel);
|
||
pruef("er sagt, dass es endgültig ist", inhalt.endgueltig);
|
||
pruef("er sagt, WAS passiert", inhalt.was.length > 10, inhalt.was);
|
||
pruef("und was BLEIBT", inhalt.bleibt.length > 10, inhalt.bleibt);
|
||
|
||
/* DER RIEGEL: Ein falsch abgetippter Name darf NICHTS loeschen. */
|
||
await seite.fill("#nachfrage-tipp", "Testolinaa");
|
||
await seite.click('dialog.nachfrage [data-teil="ja"]');
|
||
await seite.waitForTimeout(500);
|
||
const nochOffen = await seite.evaluate(() =>
|
||
!!document.querySelector("dialog.nachfrage[open]"));
|
||
pruef("ein falsch abgetippter Name schließt den Dialog NICHT", nochOffen);
|
||
const fehlertext = await seite.evaluate(() =>
|
||
document.querySelector('dialog.nachfrage [data-teil="fehler"]')?.textContent?.trim() || "");
|
||
pruef("und sagt, was erwartet wird", /Testolina/.test(fehlertext), fehlertext);
|
||
pruef("die Person ist noch da", await wieViele() === vorher);
|
||
|
||
/* Der Knopf daneben muss wirklich nichts tun. */
|
||
await seite.click('dialog.nachfrage [data-teil="nein"]');
|
||
await seite.waitForTimeout(400);
|
||
pruef("der Abbruchknopf schließt den Dialog",
|
||
!await seite.evaluate(() => !!document.querySelector("dialog.nachfrage[open]")));
|
||
pruef("und löscht nichts", await wieViele() === vorher);
|
||
|
||
/* Und jetzt richtig. */
|
||
await bestaetige(seite, () => loeschKnopf.click(), { tippen: "Testolina" });
|
||
await seite.waitForTimeout(1400);
|
||
const nachher = await wieViele();
|
||
pruef("mit richtig abgetipptem Namen wird gelöscht",
|
||
nachher === vorher - 1, `${vorher} → ${nachher}`);
|
||
}
|
||
|
||
/* Und Esc bricht ab -- auf einem Dialog OHNE Abtippen. */
|
||
await seite.goto(BASIS + "/workspace/start.html", { waitUntil: "networkidle" });
|
||
await seite.waitForTimeout(700);
|
||
await seite.click("#abmelden");
|
||
let abmeldeDialog = true;
|
||
try { await seite.waitForSelector("dialog.nachfrage[open]", { timeout: 4000 }); }
|
||
catch { abmeldeDialog = false; }
|
||
pruef("auch Abmelden fragt nach", abmeldeDialog);
|
||
if (abmeldeDialog) {
|
||
const t = await nachfrageText(seite);
|
||
pruef("und nennt den Grund: der Zugangscode", /Zugangscode/.test(t.was), t.was);
|
||
await seite.keyboard.press("Escape");
|
||
await seite.waitForTimeout(800);
|
||
pruef("Esc bricht ab – man bleibt angemeldet",
|
||
seite.url().includes("start.html"), seite.url());
|
||
}
|
||
|
||
/* ===================================================================
|
||
DIE VERWURFWACHE AM ECHTEN BILDSCHIRM (20.09.2026)
|
||
|
||
Alles oben ist Textsuche. Sie beweist, dass der Code dasteht --
|
||
nicht, dass Esc wirklich abgefangen wird, dass ein unberührter
|
||
Dialog still zugeht und dass „Verwerfen" wirklich verwirft.
|
||
|
||
Geprüft wird am größten Formular des Hauses: „Aufgabe bearbeiten",
|
||
zehn Felder. Wer dort tippt und mit dem Daumen den Rand trifft,
|
||
verlor bis heute alles, wortlos.
|
||
=================================================================== */
|
||
console.log("\n --- Die Verwurfwache am Bildschirm ---");
|
||
|
||
/* Eine Aufgabe, damit es etwas zu bearbeiten gibt. */
|
||
{
|
||
const dbz = new DatabaseSync(process.env.WORKSPACE_DB);
|
||
const wer = dbz.prepare("SELECT id FROM personen WHERE rolle = 'admin' LIMIT 1").get()?.id;
|
||
dbz.prepare("INSERT INTO aufgaben (titel, beschreibung, status, verantwortlich_id,"
|
||
+ " erstellt_von, erstellt) VALUES (?,?,?,?,?,?)")
|
||
.run("Zum Bearbeiten", "Ein Text, der nicht verlorengehen darf.",
|
||
"offen", wer, wer, new Date().toISOString());
|
||
dbz.close();
|
||
}
|
||
|
||
await seite.goto(BASIS + "/workspace/aufgaben.html", { waitUntil: "networkidle" });
|
||
await seite.waitForTimeout(900);
|
||
|
||
const auf = async () => {
|
||
await seite.click(".karte, .aufgabe, [data-id]", { timeout: 5000 }).catch(() => {});
|
||
await seite.waitForTimeout(500);
|
||
return seite.evaluate(() =>
|
||
!!document.getElementById("bearbeiten-dialog")?.open);
|
||
};
|
||
|
||
/* Erst über den Bearbeiten-Knopf an der Karte. */
|
||
let offen = await seite.evaluate(() => {
|
||
const k = [...document.querySelectorAll("button")]
|
||
.find((b) => /bearbeiten/i.test(b.textContent || "") || /bearbeiten/i.test(b.title || ""));
|
||
if (k) { k.click(); return true; }
|
||
return false;
|
||
});
|
||
await seite.waitForTimeout(700);
|
||
let istAuf = await seite.evaluate(() =>
|
||
!!document.getElementById("bearbeiten-dialog")?.open);
|
||
if (!istAuf) istAuf = await auf();
|
||
|
||
pruef("der Bearbeiten-Dialog geht auf", istAuf);
|
||
|
||
if (istAuf) {
|
||
/* 1. UNBERÜHRT -> still zu. Das ist der wichtigere Fall: Wer
|
||
nichts getippt hat, darf nichts gefragt werden. */
|
||
await seite.keyboard.press("Escape");
|
||
await seite.waitForTimeout(500);
|
||
const nachEsc = await seite.evaluate(() => ({
|
||
dialogZu: !document.getElementById("bearbeiten-dialog")?.open,
|
||
gefragt: !!document.querySelector("dialog.nachfrage[open]"),
|
||
}));
|
||
pruef("unberührt geht er ohne Nachfrage zu", nachEsc.dialogZu && !nachEsc.gefragt,
|
||
`zu: ${nachEsc.dialogZu}, gefragt: ${nachEsc.gefragt}`);
|
||
|
||
/* 2. GETIPPT -> Esc fragt nach. */
|
||
await seite.evaluate(() => {
|
||
const k = [...document.querySelectorAll("button")]
|
||
.find((b) => /bearbeiten/i.test(b.textContent || "") || /bearbeiten/i.test(b.title || ""));
|
||
k?.click();
|
||
});
|
||
await seite.waitForTimeout(600);
|
||
await seite.fill("#b-titel", "Etwas ganz anderes");
|
||
await seite.keyboard.press("Escape");
|
||
await seite.waitForTimeout(600);
|
||
const nachTippen = await seite.evaluate(() => ({
|
||
nochOffen: !!document.getElementById("bearbeiten-dialog")?.open,
|
||
gefragt: !!document.querySelector("dialog.nachfrage[open]"),
|
||
text: document.querySelector('dialog.nachfrage [data-teil="was"]')?.textContent || "",
|
||
}));
|
||
pruef("nach einer Änderung fragt Esc nach", nachTippen.gefragt,
|
||
`gefragt: ${nachTippen.gefragt}`);
|
||
pruef("und der Dialog bleibt solange offen", nachTippen.nochOffen);
|
||
pruef("die Frage sagt, was verloren geht",
|
||
/verloren/i.test(nachTippen.text), nachTippen.text);
|
||
|
||
/* 3. „Weiter bearbeiten" -> der Text steht noch da. */
|
||
await seite.click('dialog.nachfrage [data-teil="nein"]');
|
||
await seite.waitForTimeout(500);
|
||
const nachWeiter = await seite.evaluate(() => ({
|
||
nochOffen: !!document.getElementById("bearbeiten-dialog")?.open,
|
||
titel: document.getElementById("b-titel")?.value || "",
|
||
}));
|
||
pruef("Weiter bearbeiten laesst den Dialog offen", nachWeiter.nochOffen);
|
||
pruef("und der getippte Text steht noch da",
|
||
nachWeiter.titel === "Etwas ganz anderes", `„${nachWeiter.titel}"`);
|
||
|
||
/* 4. DER KNOPF-WEG -- und er muss JEDES MAL fragen.
|
||
----------------------------------------------------------------
|
||
NICHT noch einmal Esc. Gemessen am 20.09.2026: Ein ZWEITES Esc
|
||
hintereinander schliesst den Dialog, egal was die Seite tut.
|
||
Das ist Chromiums „close watcher": Eine Seite darf den Nutzer
|
||
nicht mit Esc einsperren. Die Regel ist richtig, und dagegen
|
||
anzubauen waere falsch -- also wird sie hier festgehalten statt
|
||
umgangen.
|
||
|
||
Der Knopf unterliegt ihr nicht. Er ist auch der Weg, den man am
|
||
Handy nimmt, wo es kein Esc gibt. */
|
||
await seite.click("#b-abbrechen");
|
||
await seite.waitForTimeout(600);
|
||
const nachKnopf = await seite.evaluate(() => ({
|
||
nochOffen: !!document.getElementById("bearbeiten-dialog")?.open,
|
||
gefragt: !!document.querySelector("dialog.nachfrage[open]"),
|
||
}));
|
||
pruef("auch der Abbrechen-Knopf fragt nach",
|
||
nachKnopf.gefragt && nachKnopf.nochOffen,
|
||
`gefragt: ${nachKnopf.gefragt}, noch offen: ${nachKnopf.nochOffen}`);
|
||
|
||
await seite.click('dialog.nachfrage [data-teil="ja"]', { timeout: 6000 });
|
||
await seite.waitForTimeout(700);
|
||
const nachVerwerfen = await seite.evaluate(() =>
|
||
!document.getElementById("bearbeiten-dialog")?.open);
|
||
pruef('Verwerfen schliesst den Dialog wirklich', nachVerwerfen);
|
||
|
||
/* Und danach ist nichts uebernommen worden -- verwerfen heisst
|
||
verwerfen, nicht speichern. */
|
||
const inListe = await seite.evaluate(() =>
|
||
document.body.textContent.includes("Etwas ganz anderes"));
|
||
pruef("und der verworfene Text steht nirgends in der Liste", !inListe);
|
||
}
|
||
|
||
/* =================================================================
|
||
EIN BILD IM DIALOG (02.10.2026)
|
||
|
||
VanVan (Support): „Wenn man hier im Support auf deine Frage 'geht
|
||
es wieder' reagiert und antwortet, kann man auch kein Bild
|
||
hinzufuegen."
|
||
|
||
Das Feld ist eine OPTION dieses Dialogs, damit Grund und Bild in
|
||
denselben Kasten passen -- zwei Dialoge nacheinander hiessen: Wer
|
||
beim zweiten abbricht, hat den ersten umsonst getippt.
|
||
|
||
GEPRUEFT WIRD DER MECHANISMUS, NICHT DIE SUPPORTSEITE. Der Dialog
|
||
wird hier direkt aufgerufen; dass die Supportseite ihn mit `bild`
|
||
aufruft, steht weiter oben in der Dateiprüfung. Beides zusammen
|
||
deckt den Weg ab, und keins von beidem braucht eine Meldung im
|
||
Zustand „wartet", die diese Pruefung erst herstellen muesste.
|
||
|
||
DIE VORGABE IST AUS, und das ist die wichtigste Zeile hier: Ohne
|
||
sie bekaemen die 56 anderen Rueckfragen im Haus ein Bildfeld,
|
||
nach dem niemand gefragt hat. */
|
||
console.log("\n --- Ein Bild im Dialog ---");
|
||
{
|
||
/* OHNE `bild` DARF NICHTS DASTEHEN. */
|
||
await seite.evaluate(() => {
|
||
window.__probe = window.frageNach({ titel: "Ohne Bild", grund: "Warum?" });
|
||
});
|
||
await seite.waitForSelector("dialog.nachfrage[open]", { timeout: 6000 });
|
||
const ohne = await seite.evaluate(() => {
|
||
const z = document.querySelector('dialog.nachfrage [data-teil="bildzeile"]');
|
||
return { da: !!z, versteckt: !!z && z.hidden };
|
||
});
|
||
pruef("ohne Angabe bleibt die Bildzeile verborgen",
|
||
ohne.da && ohne.versteckt);
|
||
await seite.click('dialog.nachfrage [data-teil="nein"]');
|
||
await seite.waitForTimeout(400);
|
||
|
||
/* MIT `bild` IST SIE DA -- und liefert die Datei zurueck. */
|
||
await seite.evaluate(() => {
|
||
window.__probe = window.frageNach({
|
||
titel: "Mit Bild", ja: "Senden",
|
||
grund: "Was geht noch nicht?", grundPflicht: true, grundMin: 3,
|
||
bild: "Bildschirmfoto dazu (freiwillig)",
|
||
});
|
||
});
|
||
await seite.waitForSelector("dialog.nachfrage[open]", { timeout: 6000 });
|
||
const mit = await seite.evaluate(() => {
|
||
const z = document.querySelector('dialog.nachfrage [data-teil="bildzeile"]');
|
||
const k = document.querySelector('dialog.nachfrage [data-teil="bildwaehlen"]');
|
||
const r = k ? k.getBoundingClientRect() : null;
|
||
return {
|
||
sichtbar: !!z && !z.hidden,
|
||
schild: document.querySelector('dialog.nachfrage [data-teil="bildschild"]')
|
||
?.textContent || "",
|
||
knopfHoch: r ? Math.round(r.height) : 0,
|
||
/* „Noch keins gewählt" statt einer leeren Zeile: Wer nichts
|
||
sieht, weiss nicht, ob er etwas vergessen hat. */
|
||
name: document.querySelector('dialog.nachfrage [data-teil="bildname"]')
|
||
?.textContent || "",
|
||
wegVerborgen: document.querySelector('dialog.nachfrage [data-teil="bildweg"]')?.hidden,
|
||
};
|
||
});
|
||
pruef("mit Angabe steht die Bildzeile da", mit.sichtbar);
|
||
pruef(` mit der Beschriftung aus dem Aufruf („${mit.schild}")`,
|
||
/Bildschirmfoto/.test(mit.schild));
|
||
pruef(` der Knopf ist ${mit.knopfHoch} px hoch (Fingermass 44)`,
|
||
mit.knopfHoch >= 44);
|
||
pruef(` und es steht da, dass noch keins gewählt ist („${mit.name}")`,
|
||
/Noch keins/.test(mit.name));
|
||
pruef(" der Entfernen-Knopf ist noch verborgen", mit.wegVerborgen === true);
|
||
|
||
/* EIN BILD WAEHLEN -- mit einer echten Datei, nicht mit einem
|
||
vorgetaeuschten Ereignis. */
|
||
await seite.setInputFiles("dialog.nachfrage #nachfrage-bild", {
|
||
name: "bildschirm.png", mimeType: "image/png", buffer: PNG_PROBE,
|
||
});
|
||
await seite.waitForTimeout(400);
|
||
const gewaehlt = await seite.evaluate(() => {
|
||
/* EIN KASTEN MIT EINER LISTE statt eines einzelnen <img>
|
||
(02.10.2026): Seit VanVans Meldung #11 koennen es bis zu
|
||
drei sein, und `bildMax` entscheidet, wie viele. */
|
||
const kasten = document.querySelector('dialog.nachfrage [data-teil="bildvorschauen"]');
|
||
const schau = kasten?.querySelector("img") || null;
|
||
return {
|
||
name: document.querySelector('dialog.nachfrage [data-teil="bildname"]')
|
||
?.textContent || "",
|
||
wegDa: document.querySelector('dialog.nachfrage [data-teil="bildweg"]')?.hidden === false,
|
||
vorschau: !!kasten && !kasten.hidden && !!schau
|
||
&& (schau.getAttribute("src") || "").length > 0,
|
||
hoch: schau ? Math.round(schau.getBoundingClientRect().height) : 0,
|
||
};
|
||
});
|
||
pruef(` nach der Wahl steht der Name da („${gewaehlt.name}")`,
|
||
/bildschirm\.png/.test(gewaehlt.name));
|
||
pruef(" der Entfernen-Knopf erscheint", gewaehlt.wegDa);
|
||
/* WER SIEHT, WAS ER ANHAENGT, haengt seltener das falsche Bild an
|
||
-- dieselbe Ueberlegung wie beim Melden. */
|
||
pruef(" und eine Vorschau ist da", gewaehlt.vorschau);
|
||
|
||
/* ==== UND JETZT MIT EINEM HOHEN BILD =========================
|
||
|
||
Hier stand die Grenze zuerst am 1x1-Bild von oben gemessen:
|
||
„3 px, hoechstens 160". Das ist gruen und wertlos -- ein ein
|
||
Pixel hohes Bild kann keine Obergrenze ueberschreiten. Genau
|
||
die Sorte Haken, vor der die Hausregeln warnen.
|
||
|
||
Ein hochkantes Bildschirmfoto vom Handy ist der echte Fall:
|
||
Ohne Deckel waere es hoeher als der ganze Dialog, und die
|
||
Knoepfe darunter waeren nicht mehr zu sehen. Das Bild entsteht
|
||
im Browser (300x900) und kommt als ECHTE Datei in das Feld --
|
||
mit `DataTransfer`, nicht mit einem vorgetaeuschten Ereignis. */
|
||
const hoch = await seite.evaluate(async () => {
|
||
const c = document.createElement("canvas");
|
||
c.width = 300; c.height = 900;
|
||
const g = c.getContext("2d");
|
||
g.fillStyle = "#2b6cb0"; g.fillRect(0, 0, c.width, c.height);
|
||
const blob = await new Promise((r) => c.toBlob(r, "image/png"));
|
||
const dt = new DataTransfer();
|
||
dt.items.add(new File([blob], "hochkant.png", { type: "image/png" }));
|
||
const feld = document.querySelector("dialog.nachfrage #nachfrage-bild");
|
||
feld.files = dt.files;
|
||
feld.dispatchEvent(new Event("change", { bubbles: true }));
|
||
await new Promise((r) => setTimeout(r, 300));
|
||
const schau = document.querySelector('dialog.nachfrage .nachfrage__vorschau img');
|
||
const dlg = document.querySelector("dialog.nachfrage");
|
||
const ja = document.querySelector('dialog.nachfrage [data-teil="ja"]');
|
||
const r = schau.getBoundingClientRect();
|
||
return {
|
||
echt: schau.naturalHeight,
|
||
gezeigt: Math.round(r.height),
|
||
breit: Math.round(r.width),
|
||
/* DER EIGENTLICHE PUNKT: Der Senden-Knopf muss noch im Fenster
|
||
stehen. Eine Obergrenze ist kein Selbstzweck. */
|
||
jaImFenster: (() => {
|
||
const j = ja.getBoundingClientRect();
|
||
return j.bottom <= window.innerHeight && j.height > 0;
|
||
})(),
|
||
dialogHoch: Math.round(dlg.getBoundingClientRect().height),
|
||
};
|
||
});
|
||
/* 120 STATT 160 SEIT DEM 02.10.2026. Der Deckel ist gesunken,
|
||
weil in dem Kasten jetzt bis zu drei Bilder nebeneinander
|
||
stehen koennen -- bei 160 waere der Senden-Knopf bei drei
|
||
hochkanten Bildern aus dem Fenster. Die Zahl steht in
|
||
module.css und wird hier nachgemessen, nicht geraten. */
|
||
pruef(` ein 300x900 grosses Bild wird auf ${hoch.gezeigt} px gedeckelt`
|
||
+ ` (echt ${hoch.echt}, höchstens 120)`,
|
||
hoch.echt === 900 && hoch.gezeigt > 0 && hoch.gezeigt <= 120);
|
||
pruef(` und es bleibt in der Breite (${hoch.breit} px)`, hoch.breit <= 300);
|
||
pruef(` der Senden-Knopf steht weiter im Fenster (Dialog ${hoch.dialogHoch} px)`,
|
||
hoch.jaImFenster);
|
||
|
||
await seite.fill("dialog.nachfrage #nachfrage-grund", "Geht noch nicht, siehe Bild.");
|
||
await seite.click('dialog.nachfrage [data-teil="ja"]');
|
||
await seite.waitForTimeout(500);
|
||
const erg = await seite.evaluate(async () => {
|
||
const a = await window.__probe;
|
||
/* `bilder` UND NICHT `bild` (02.10.2026): Der Dialog gibt
|
||
immer eine Liste zurueck, auch wenn nur eines erlaubt war.
|
||
Ein Sonderfall „genau eines" waere die zweite Auskunft auf
|
||
dieselbe Frage -- und die veraltet. */
|
||
const eins = a && Array.isArray(a.bilder) ? a.bilder[0] : null;
|
||
return {
|
||
grund: a && a.grund,
|
||
anzahl: a && Array.isArray(a.bilder) ? a.bilder.length : -1,
|
||
bildName: eins ? eins.name : null,
|
||
bildTyp: eins ? eins.type : null,
|
||
istDatei: !!(eins && typeof eins.size === "number"),
|
||
};
|
||
});
|
||
pruef(`der Dialog gibt den Grund zurück („${erg.grund}")`,
|
||
/siehe Bild/.test(erg.grund || ""));
|
||
pruef(` er gibt eine LISTE zurueck, nicht ein Feld (${erg.anzahl})`,
|
||
erg.anzahl === 1);
|
||
pruef(` und die Datei dazu (${erg.bildName}, ${erg.bildTyp})`,
|
||
/* und nicht : Zwei Zeilen
|
||
weiter oben wurde das Bild ERSETZT. Meine erste Fassung
|
||
erwartete noch das erste und wurde rot -- die Pruefung
|
||
hatte recht, die Erwartung war veraltet. */
|
||
erg.istDatei && erg.bildName === "hochkant.png" && erg.bildTyp === "image/png");
|
||
|
||
/* GEGENPROBE: Abbrechen gibt gar nichts zurueck -- auch nicht das
|
||
Bild. Ohne diese Zeile koennte ein Abbruch trotzdem etwas
|
||
hochladen. */
|
||
await seite.evaluate(() => {
|
||
window.__probe2 = window.frageNach({
|
||
titel: "Abbrechen", grund: "Warum?", bild: "Bild dazu",
|
||
});
|
||
});
|
||
await seite.waitForSelector("dialog.nachfrage[open]", { timeout: 6000 });
|
||
await seite.setInputFiles("dialog.nachfrage #nachfrage-bild", {
|
||
name: "egal.png", mimeType: "image/png", buffer: PNG_PROBE,
|
||
});
|
||
await seite.waitForTimeout(300);
|
||
await seite.click('dialog.nachfrage [data-teil="nein"]');
|
||
await seite.waitForTimeout(400);
|
||
const abbruch = await seite.evaluate(async () => await window.__probe2);
|
||
pruef("Gegenprobe: Abbrechen gibt nichts zurück, auch kein Bild",
|
||
abbruch === false);
|
||
|
||
/* UND JEDES OEFFNEN FAENGT LEER AN. Ohne das haengt beim zweiten
|
||
Mal noch das Bild vom ersten dran -- und niemand sieht es,
|
||
weil der Dialog oben schon zu war. */
|
||
await seite.evaluate(() => {
|
||
window.__probe3 = window.frageNach({
|
||
titel: "Nochmal", grund: "Warum?", bild: "Bild dazu",
|
||
});
|
||
});
|
||
await seite.waitForSelector("dialog.nachfrage[open]", { timeout: 6000 });
|
||
const frisch = await seite.evaluate(() =>
|
||
document.querySelector('dialog.nachfrage [data-teil="bildname"]')?.textContent || "");
|
||
pruef(` und beim nächsten Öffnen ist es leer („${frisch}")`,
|
||
/Noch keins/.test(frisch));
|
||
await seite.click('dialog.nachfrage [data-teil="nein"]');
|
||
await seite.waitForTimeout(300);
|
||
|
||
/* ==== UND MIT `bildMax` SIND ES MEHRERE (02.10.2026) =========
|
||
|
||
VanVan im Support, Meldung #11: „2-3 wären besser." Der
|
||
Dialog kann das seither; ohne Angabe bleibt es bei einem,
|
||
damit sich fuer jeden anderen Aufruf im Haus nichts aendert.
|
||
|
||
DER UNTERSCHIED ZUM FALL DARUEBER IST DER PUNKT: Dort hat die
|
||
zweite Wahl die erste ERSETZT (ein Platz, eine Korrektur),
|
||
hier muss sie DAZUKOMMEN. Beides in derselben Pruefung, sonst
|
||
beweist keines etwas. */
|
||
await seite.evaluate(() => {
|
||
window.__probe4 = window.frageNach({
|
||
titel: "Mit dreien", ja: "Senden",
|
||
grund: "Was geht noch nicht?", grundPflicht: true, grundMin: 3,
|
||
bild: "Bildschirmfotos dazu (freiwillig)", bildMax: 3,
|
||
});
|
||
});
|
||
await seite.waitForSelector("dialog.nachfrage[open]", { timeout: 6000 });
|
||
const zaehl = () => seite.evaluate(() =>
|
||
document.querySelectorAll("dialog.nachfrage .nachfrage__vorschau").length);
|
||
for (const name of ["a.png", "b.png", "c.png", "d.png"]) {
|
||
await seite.setInputFiles("dialog.nachfrage #nachfrage-bild", {
|
||
name, mimeType: "image/png", buffer: PNG_PROBE,
|
||
});
|
||
await seite.waitForTimeout(250);
|
||
}
|
||
const dreiDa = await zaehl();
|
||
pruef(`mit bildMax 3 legt jede Wahl DAZU (${dreiDa} nach vier Griffen)`,
|
||
dreiDa === 3);
|
||
const grenzWort = await seite.evaluate(() =>
|
||
document.querySelector('dialog.nachfrage [data-teil="fehler"]')?.textContent || "");
|
||
pruef(` und das vierte wird mit einem Satz abgelehnt („${grenzWort}")`,
|
||
/3 Bilder/.test(grenzWort));
|
||
|
||
/* EINZELN WEGNEHMEN, nicht alles. */
|
||
await seite.click("dialog.nachfrage .nachfrage__vorschau:nth-child(2) "
|
||
+ ".nachfrage__vorschau-weg");
|
||
await seite.waitForTimeout(200);
|
||
pruef(` eines einzeln entfernen laesst die anderen stehen (${await zaehl()})`,
|
||
await zaehl() === 2);
|
||
|
||
await seite.fill("dialog.nachfrage #nachfrage-grund", "Hier zwei Bilder dazu.");
|
||
await seite.click('dialog.nachfrage [data-teil="ja"]');
|
||
await seite.waitForTimeout(400);
|
||
const viele = await seite.evaluate(async () => {
|
||
const a = await window.__probe4;
|
||
return (a && Array.isArray(a.bilder)) ? a.bilder.map((b) => b.name) : null;
|
||
});
|
||
pruef(` und der Dialog gibt beide zurueck (${(viele || []).join(", ")})`,
|
||
Array.isArray(viele) && viele.length === 2
|
||
&& viele[0] === "a.png" && viele[1] === "c.png");
|
||
|
||
/* ==== EIN DATUM UND EIN HAKEN (02.10.2026) ==================
|
||
|
||
VanVan im Support, Meldung #6: „Bei den Vorlagen laesst sich
|
||
weder die Frist anpassen noch ‚dauerhaft' einstellen, und eine
|
||
Anmerkung fehlt auch." Die Anmerkung gab es hier schon
|
||
(`grund`), die zwei anderen Felder nicht.
|
||
|
||
SIE STEHEN IM GEMEINSAMEN FENSTER und nicht in
|
||
vorlagenbrett.js -- sonst waere das der zweite Dialog im Haus,
|
||
in dem Esc, Fokus und Abbruch von Hand nachgebaut werden
|
||
muessten. */
|
||
await seite.evaluate(() => {
|
||
window.__probe5 = window.frageNach({
|
||
titel: "Anpassen", ja: "Übernehmen",
|
||
datum: "Frist", datumWert: "2030-05-17", datumMin: "2026-10-01",
|
||
haken: "Dauerhafte Aufgabe", hakenHinweis: "Sie wird nicht abgehakt.",
|
||
hakenSperrtDatum: true,
|
||
grund: "Anmerkung (freiwillig)",
|
||
});
|
||
});
|
||
await seite.waitForSelector("dialog.nachfrage[open]", { timeout: 6000 });
|
||
const dh = await seite.evaluate(() => {
|
||
const dlg = document.querySelector("dialog.nachfrage");
|
||
const dfeld = dlg.querySelector("#nachfrage-datum");
|
||
const hfeld = dlg.querySelector("#nachfrage-haken");
|
||
const etikett = dlg.querySelector(".nachfrage__haken");
|
||
return {
|
||
datumDa: !dlg.querySelector('[data-teil="datumzeile"]').hidden,
|
||
wert: dfeld.value, min: dfeld.min,
|
||
hakenDa: !dlg.querySelector('[data-teil="hakenzeile"]').hidden,
|
||
hakenAn: hfeld.checked,
|
||
hinweis: dlg.querySelector('[data-teil="hakenhinweis"]').textContent,
|
||
/* 44 Pixel, wie jeder Knopf im Haus -- und die Flaeche kommt
|
||
vom Etikett, nicht vom Kaestchen. */
|
||
etikettHoch: Math.round(etikett.getBoundingClientRect().height),
|
||
kaestchen: Math.round(hfeld.getBoundingClientRect().width),
|
||
};
|
||
});
|
||
pruef(`das Datumsfeld steht da, mit Vorgabe („${dh.wert}")`,
|
||
dh.datumDa && dh.wert === "2030-05-17");
|
||
pruef(` und mit einer Untergrenze (${dh.min})`, dh.min === "2026-10-01");
|
||
pruef(`der Haken steht da und ist aus (${dh.hakenAn})`,
|
||
dh.hakenDa && dh.hakenAn === false);
|
||
pruef(` sein Etikett ist ${dh.etikettHoch} px hoch (Fingermass 44)`,
|
||
dh.etikettHoch >= 44);
|
||
/* EIN ANKREUZFELD UEBER DIE GANZE ZEILE sieht aus wie ein leeres
|
||
Textfeld -- die Regel `.nachfrage__form input { width: 100% }`
|
||
haette genau das gemacht. */
|
||
pruef(` und das Kaestchen ist ${dh.kaestchen} px breit, nicht die ganze Zeile`,
|
||
dh.kaestchen > 10 && dh.kaestchen < 60);
|
||
pruef(` der Hinweis steht dabei („${dh.hinweis}")`, /nicht abgehakt/.test(dh.hinweis));
|
||
|
||
/* DER HAKEN SPERRT DAS DATUM. Eine dauerhafte Aufgabe hat keine
|
||
Frist -- ein Datum, das dasteht und nicht gilt, ist schlimmer
|
||
als keins. */
|
||
await seite.check("dialog.nachfrage #nachfrage-haken");
|
||
await seite.waitForTimeout(150);
|
||
const gesperrt = await seite.evaluate(() => {
|
||
const dlg = document.querySelector("dialog.nachfrage");
|
||
return {
|
||
aus: dlg.querySelector("#nachfrage-datum").disabled,
|
||
blass: parseFloat(getComputedStyle(
|
||
dlg.querySelector('[data-teil="datumzeile"]')).opacity) < 1,
|
||
};
|
||
});
|
||
pruef(`mit Haken wird das Datum gesperrt (${gesperrt.aus})`, gesperrt.aus === true);
|
||
pruef(" und sieht auch gesperrt aus", gesperrt.blass === true);
|
||
|
||
/* GEGENPROBE: Haken wieder weg -> das Datum geht wieder. Ohne sie
|
||
koennte die Sperre dauerhaft sein und die Zeile oben waere
|
||
trotzdem gruen. */
|
||
await seite.uncheck("dialog.nachfrage #nachfrage-haken");
|
||
await seite.waitForTimeout(150);
|
||
pruef("Gegenprobe: ohne Haken geht das Datum wieder",
|
||
(await seite.evaluate(() =>
|
||
document.querySelector("dialog.nachfrage #nachfrage-datum").disabled)) === false);
|
||
|
||
/* ==== EIN DATUM VOR DER UNTERGRENZE -- ZWEI SCHRANKEN =======
|
||
|
||
Die erste ist das `min` am Feld: Der Datumswaehler bietet
|
||
fruehere Tage gar nicht erst an, und der Browser laesst das
|
||
Formular nicht abschicken. Das ist die freundlichere -- sie
|
||
greift, bevor jemand etwas tippt.
|
||
|
||
GEMESSEN WIRD, DASS SIE WIRKLICH GREIFT, nicht dass sie
|
||
dasteht: `rangeUnderflow` sagt es, das Attribut allein nicht.
|
||
Mein erster Anlauf erwartete hier den HAUSEIGENEN Fehlersatz
|
||
und wurde rot -- zu Recht: Der Browser haelt das Formular
|
||
vorher an, mein Handler laeuft gar nicht. Die Pruefung hatte
|
||
recht, die Erwartung war falsch.
|
||
|
||
DIE ZWEITE SCHRANKE steht im Skript und wird darunter einzeln
|
||
geprueft -- mit abgenommenem `min`, sonst kaeme sie nie zum
|
||
Zug. Zwei Schranken sind hier keine Dopplung: Die eine ist
|
||
Bedienkomfort, die andere die Regel. Wer `min` morgen
|
||
entfernt, hat immer noch die Regel. */
|
||
await seite.fill("dialog.nachfrage #nachfrage-datum", "2020-01-01");
|
||
await seite.click('dialog.nachfrage [data-teil="ja"]');
|
||
await seite.waitForTimeout(250);
|
||
const nochOffen = await seite.evaluate(() => {
|
||
const f = document.querySelector("dialog.nachfrage #nachfrage-datum");
|
||
return {
|
||
offen: !!document.querySelector("dialog.nachfrage[open]"),
|
||
zuFrueh: f.validity.rangeUnderflow,
|
||
};
|
||
});
|
||
pruef(`ein Datum vor der Untergrenze haelt den Dialog auf (offen ${nochOffen.offen})`,
|
||
nochOffen.offen === true);
|
||
pruef(` der Browser nennt es zu frueh (rangeUnderflow ${nochOffen.zuFrueh})`,
|
||
nochOffen.zuFrueh === true);
|
||
|
||
/* UND JETZT OHNE `min`: Nur so kommt die Regel im Skript dran. */
|
||
await seite.evaluate(() =>
|
||
document.querySelector("dialog.nachfrage #nachfrage-datum").removeAttribute("min"));
|
||
await seite.click('dialog.nachfrage [data-teil="ja"]');
|
||
await seite.waitForTimeout(250);
|
||
const eigene = await seite.evaluate(() => ({
|
||
offen: !!document.querySelector("dialog.nachfrage[open]"),
|
||
fehler: document.querySelector('dialog.nachfrage [data-teil="fehler"]')?.textContent || "",
|
||
}));
|
||
pruef(`ohne Untergrenze faengt es das Skript ab („${eigene.fehler}")`,
|
||
eigene.offen && /Vergangenheit/.test(eigene.fehler));
|
||
|
||
await seite.fill("dialog.nachfrage #nachfrage-datum", "2030-06-01");
|
||
await seite.check("dialog.nachfrage #nachfrage-haken");
|
||
await seite.fill("dialog.nachfrage #nachfrage-grund", "Ein Wort dazu.");
|
||
await seite.click('dialog.nachfrage [data-teil="ja"]');
|
||
await seite.waitForTimeout(400);
|
||
const erg5 = await seite.evaluate(async () => {
|
||
const a = await window.__probe5;
|
||
return a === false ? null : { datum: a.datum, haken: a.haken, grund: a.grund };
|
||
});
|
||
pruef(`der Dialog gibt den Haken zurueck (${erg5?.haken})`, erg5?.haken === true);
|
||
/* UND DAS DATUM IST LEER, weil der Haken es gesperrt hat. Haette
|
||
es den Wert behalten, schickte der Browser etwas mit, das der
|
||
Server wegwirft -- und beim naechsten Lesen stuende in der
|
||
Antwort etwas anderes als in der Datenbank. */
|
||
pruef(` und das gesperrte Datum kommt LEER zurueck („${erg5?.datum}")`,
|
||
erg5?.datum === "");
|
||
pruef(` die Anmerkung kommt mit („${erg5?.grund}")`, erg5?.grund === "Ein Wort dazu.");
|
||
}
|
||
|
||
pruef("keine Abst\u00fcrze im Browser", abstuerze.length === 0, abstuerze[0] || "");
|
||
|
||
await browser.close();
|
||
try { rmSync(ordner, { recursive: true, force: true }); } catch { /* egal */ }
|
||
}
|
||
|
||
console.log(`\n ${ok} bestanden, ${fehl} fehlgeschlagen`);
|
||
console.log(` (${gezaehlt} Rückfragen in ${nutzer.size} Dateien, `
|
||
+ `${mitNutzung} Seiten)\n`);
|
||
process.exit(fehl ? 1 : 0);
|