Stufe 0: Grundgerüst mit Rechenkern, Datenbank, Oberfläche und Docker-Betrieb

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01AmyPfuNc4sCRfaF3oURXZz
This commit is contained in:
Claude
2026-10-17 16:37:54 +00:00
commit 92d26baa4b
45 changed files with 6143 additions and 0 deletions

357
src/web/app.ts Normal file
View File

@@ -0,0 +1,357 @@
// Oberfläche Stufe 0. Die Reiter folgen V70; Terminplan und Projektdetails
// kommen mit der Übernahme der V70-Oberfläche.
import { formatEuro, parseEuro } from "../domain/geld.js";
import { formatDatum } from "../domain/datum.js";
type Zeile = Record<string, any>;
// ---------- Hilfen ----------
function esc(v: unknown): string {
return String(v ?? "").replace(/[&<>"']/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[c]!);
}
async function api<T = any>(pfad: string, methode = "GET", body?: unknown): Promise<T> {
const r = await fetch(`/api/${pfad}`, {
method: methode,
headers: body === undefined ? {} : { "content-type": "application/json" },
body: body === undefined ? undefined : JSON.stringify(body),
});
if (r.status === 204) return undefined as T;
const j = await r.json().catch(() => ({}));
if (!r.ok) throw new Error([j.fehler ?? `Fehler ${r.status}`, ...(j.details ?? [])].join("\n"));
return j as T;
}
const inhalt = document.getElementById("inhalt")!;
const huelle = document.getElementById("dialog-huelle")!;
const heute = () => new Date().toISOString().slice(0, 10);
const euro = (c: number | null | undefined) => (c == null ? "" : formatEuro(c));
const dat = (d: string | null | undefined) => (d ? formatDatum(d) : "");
// ---------- Eigene Dialoge (keine Browser-Abfragen) ----------
interface Feld {
name: string;
titel: string;
art?: "text" | "euro" | "datum" | "auswahl" | "zahl" | "langtext";
optionen?: [string, string][];
pflicht?: boolean;
}
function dialog(titel: string, felder: Feld[], werte: Zeile, mitLoeschen: boolean): Promise<{ aktion: "speichern"; daten: Zeile } | { aktion: "loeschen" } | null> {
return new Promise((fertig) => {
const feldHtml = felder
.map((f) => {
const v = werte[f.name];
const id = `f-${f.name}`;
let eingabe: string;
if (f.art === "auswahl") {
eingabe = `<select id="${id}">${f.optionen!.map(([w, t]) => `<option value="${esc(w)}"${w === (v ?? "") ? " selected" : ""}>${esc(t)}</option>`).join("")}</select>`;
} else if (f.art === "langtext") {
eingabe = `<textarea id="${id}" rows="3">${esc(v)}</textarea>`;
} else {
const typ = f.art === "datum" ? "date" : "text";
const anzeige = f.art === "euro" && v != null ? formatEuro(v, false) : v;
eingabe = `<input id="${id}" type="${typ}" value="${esc(anzeige)}"${f.art === "euro" || f.art === "zahl" ? ' inputmode="decimal"' : ""}>`;
}
return `<label for="${id}">${esc(f.titel)}${f.pflicht ? " *" : ""}</label>${eingabe}`;
})
.join("");
huelle.innerHTML = `<form class="dialog"><h2>${esc(titel)}</h2>${feldHtml}<p class="fehler" id="dialog-fehler"></p>
<div class="knoepfe">${mitLoeschen ? '<button type="button" class="neben links" data-a="loeschen">Löschen</button>' : ""}
<button type="button" class="neben" data-a="abbrechen">Abbrechen</button><button type="submit" class="haupt">Speichern</button></div></form>`;
huelle.hidden = false;
const form = huelle.querySelector("form")!;
const schliessen = (e: Parameters<typeof fertig>[0]) => {
huelle.hidden = true;
huelle.innerHTML = "";
document.removeEventListener("keydown", taste);
fertig(e);
};
const taste = (ev: KeyboardEvent) => ev.key === "Escape" && schliessen(null);
document.addEventListener("keydown", taste);
(form.querySelector("input,select,textarea") as HTMLElement | null)?.focus();
form.addEventListener("click", (ev) => {
const a = (ev.target as HTMLElement).dataset.a;
if (a === "abbrechen") schliessen(null);
if (a === "loeschen") bestaetigen("Wirklich löschen?").then((ja) => ja && schliessen({ aktion: "loeschen" }));
});
form.addEventListener("submit", (ev) => {
ev.preventDefault();
const daten: Zeile = {};
try {
for (const f of felder) {
const roh = (form.querySelector(`#f-${f.name}`) as HTMLInputElement).value.trim();
if (f.pflicht && !roh) throw new Error(`${f.titel} fehlt`);
if (f.art === "euro") daten[f.name] = roh ? parseEuro(roh) : f.pflicht ? 0 : null;
else if (f.art === "zahl") daten[f.name] = roh ? Number(roh.replace(",", ".")) : null;
else daten[f.name] = roh || null;
}
} catch (e) {
form.querySelector("#dialog-fehler")!.textContent = (e as Error).message;
return;
}
schliessen({ aktion: "speichern", daten });
});
});
}
function bestaetigen(frage: string): Promise<boolean> {
return new Promise((fertig) => {
const box = document.createElement("div");
box.className = "dialog";
box.style.position = "fixed";
box.innerHTML = `<h2>${esc(frage)}</h2><div class="knoepfe"><button class="neben" data-a="nein">Abbrechen</button><button class="haupt" data-a="ja">Ja</button></div>`;
huelle.appendChild(box);
box.addEventListener("click", (ev) => {
const a = (ev.target as HTMLElement).dataset.a;
if (!a) return;
box.remove();
fertig(a === "ja");
});
});
}
async function bearbeiten(pfad: string, titel: string, felder: Feld[], zeile: Zeile | null, vorgaben: Zeile = {}): Promise<boolean> {
const e = await dialog(titel, felder, zeile ?? vorgaben, !!zeile);
if (!e) return false;
if (e.aktion === "loeschen") await api(`${pfad}/${zeile!.id}`, "DELETE");
else if (zeile) await api(`${pfad}/${zeile.id}`, "PATCH", e.daten);
else await api(pfad, "POST", { ...vorgaben, ...e.daten });
return true;
}
function tabelle(spalten: { titel: string; wert: (z: Zeile) => string; klasse?: string }[], zeilen: Zeile[], klick?: (z: Zeile) => void): HTMLTableElement {
const t = document.createElement("table");
t.innerHTML = `<thead><tr>${spalten.map((s) => `<th class="${s.klasse ?? ""}">${esc(s.titel)}</th>`).join("")}</tr></thead>
<tbody>${zeilen.map((z, i) => `<tr data-i="${i}" class="${klick ? "klickbar" : ""}">${spalten.map((s) => `<td class="${s.klasse ?? ""}">${s.wert(z)}</td>`).join("")}</tr>`).join("")}</tbody>`;
if (klick) t.addEventListener("click", (ev) => {
const tr = (ev.target as HTMLElement).closest("tr[data-i]") as HTMLElement | null;
if (tr) klick(zeilen[Number(tr.dataset.i)]!);
});
return t;
}
function seite(titel: string, knopf?: { text: string; aktion: () => void }): HTMLElement {
inhalt.innerHTML = `<h1>${esc(titel)}</h1>`;
const leiste = document.createElement("div");
leiste.className = "leiste";
if (knopf) {
const b = document.createElement("button");
b.className = "haupt";
b.textContent = knopf.text;
b.onclick = knopf.aktion;
leiste.appendChild(b);
}
inhalt.appendChild(leiste);
return leiste;
}
// ---------- Reiter ----------
const ROLLEN: [string, string][] = [
["bauherr", "Bauherr"], ["subunternehmer", "Subunternehmer"], ["lieferant", "Lieferant"],
["planer", "Planer"], ["mitarbeiter", "Mitarbeiter"], ["sonstige", "Sonstige"],
];
const KONTAKT_FELDER: Feld[] = [
{ name: "name", titel: "Name", pflicht: true }, { name: "firma", titel: "Firma" },
{ name: "rolle", titel: "Rolle", art: "auswahl", optionen: ROLLEN }, { name: "gewerk", titel: "Gewerk" },
{ name: "telefon", titel: "Telefon" }, { name: "email", titel: "E-Mail" }, { name: "notiz", titel: "Notiz", art: "langtext" },
];
async function kontakte(): Promise<void> {
const neu = async () => (await bearbeiten("kontakte", "Neuer Kontakt", KONTAKT_FELDER, null)) && kontakte();
seite("Kontakte", { text: "Neuer Kontakt", aktion: neu });
const zeilen = await api<Zeile[]>("kontakte");
const rolle = Object.fromEntries(ROLLEN);
inhalt.appendChild(tabelle([
{ titel: "Name", wert: (z) => esc(z.name) },
{ titel: "Firma", wert: (z) => esc(z.firma), klasse: "optional" },
{ titel: "Rolle", wert: (z) => esc(rolle[z.rolle]) },
{ titel: "Telefon", wert: (z) => (z.telefon ? `<a href="tel:${esc(z.telefon)}">${esc(z.telefon)}</a>` : "") },
{ titel: "E-Mail", wert: (z) => esc(z.email), klasse: "optional" },
], zeilen, async (z) => (await bearbeiten("kontakte", "Kontakt bearbeiten", KONTAKT_FELDER, z)) && kontakte()));
}
async function projekte(): Promise<void> {
const kontaktListe = await api<Zeile[]>("kontakte");
const felder: Feld[] = [
{ name: "nummer", titel: "Nummer", pflicht: true }, { name: "bezeichnung", titel: "Baustelle", pflicht: true },
{ name: "bauherr_id", titel: "Bauherr", art: "auswahl", optionen: [["", "–"], ...kontaktListe.map((k): [string, string] => [k.id, k.name])] },
{ name: "umsatz_netto", titel: "Umsatz netto", art: "euro" }, { name: "material_kosten", titel: "Materialkosten", art: "euro" },
{ name: "fremd_kosten", titel: "Fremdkosten", art: "euro" }, { name: "sonstige_kosten", titel: "Sonstige Kosten", art: "euro" },
];
const ohneNull = (z: Zeile | null) => z && { ...z, ...Object.fromEntries(["umsatz_netto", "material_kosten", "fremd_kosten", "sonstige_kosten"].map((k) => [k, z[k] ?? 0])) };
const speichern = async (z: Zeile | null) => {
if (await bearbeiten("projekte", z ? "Projekt bearbeiten" : "Neues Projekt", felder, z)) projekte();
};
seite("Projekte", { text: "Neues Projekt", aktion: () => speichern(null) });
const zeilen = await api<Zeile[]>("projekte");
const name = Object.fromEntries(kontaktListe.map((k) => [k.id, k.name]));
const kostenSumme = (z: Zeile) => z.material_kosten + z.fremd_kosten + z.sonstige_kosten;
inhalt.appendChild(tabelle([
{ titel: "Nr.", wert: (z) => esc(z.nummer) },
{ titel: "Baustelle", wert: (z) => esc(z.bezeichnung) },
{ titel: "Bauherr", wert: (z) => esc(name[z.bauherr_id]), klasse: "optional" },
{ titel: "Umsatz netto", wert: (z) => euro(z.umsatz_netto), klasse: "zahl" },
{ titel: "Kosten", wert: (z) => euro(kostenSumme(z)), klasse: "zahl optional" },
{ titel: "Rohertrag", wert: (z) => euro(z.umsatz_netto - kostenSumme(z)), klasse: "zahl" },
], zeilen, (z) => speichern(ohneNull(z))));
const gesamt = zeilen.reduce((s, z) => s + z.umsatz_netto - kostenSumme(z), 0);
inhalt.insertAdjacentHTML("beforeend", `<p>Rohertrag gesamt: <strong>${euro(gesamt)}</strong></p>
<p class="hinweis">Projektdetailseite, Einzelposten und Zahlungsplan folgen mit der V70-Übernahme.</p>`);
}
async function terminplan(): Promise<void> {
seite("Terminplan");
inhalt.insertAdjacentHTML("beforeend", `<p class="hinweis">Der Gantt-Terminplan aus V70 wird als Nächstes übernommen. Arbeitstage (Mo–Do, Feiertage Schleswig-Holstein) und Stundenumrechnung sind bereits fertig und geprüft.</p>`);
}
async function liquiditaetSeite(ansicht = "woche", anzahl = 8): Promise<void> {
const leiste = seite("Liquidität");
leiste.innerHTML = `<select id="l-ansicht"><option value="woche">Wochen</option><option value="monat">Monate</option></select>
<select id="l-anzahl">${[4, 8, 12, 26, 52].map((n) => `<option>${n}</option>`).join("")}</select>`;
const a = leiste.querySelector("#l-ansicht") as HTMLSelectElement;
const n = leiste.querySelector("#l-anzahl") as HTMLSelectElement;
a.value = ansicht;
n.value = String(anzahl);
a.onchange = n.onchange = () => liquiditaetSeite(a.value, Number(n.value));
const perioden = await api<Zeile[]>(`liquiditaet?ansicht=${ansicht}&anzahl=${anzahl}&start=${heute()}`);
inhalt.appendChild(tabelle([
{ titel: ansicht === "woche" ? "Woche ab" : "Monat", wert: (p) => (ansicht === "woche" ? dat(p.von) : esc(p.von.slice(5, 7) + "/" + p.von.slice(0, 4))) },
{ titel: "Einnahmen", wert: (p) => euro(p.einnahmen), klasse: "zahl" },
{ titel: "Ausgaben", wert: (p) => euro(p.ausgaben), klasse: "zahl" },
{ titel: "Saldo", wert: (p) => euro(p.saldo), klasse: "zahl optional" },
{ titel: "Kontostand", wert: (p) => `<span class="${p.kontostand < 0 ? "fehler" : ""}">${euro(p.kontostand)}</span>`, klasse: "zahl" },
], perioden, (p) => {
const text = p.posten.map((x: Zeile) => `${dat(x.datum)} ${x.gruppe} ${x.projekt ?? ""} ${x.bezeichnung}: ${formatEuro(x.betrag)}`).join("\n") || "Keine Bewegungen";
dialog(`${dat(p.von)} bis ${dat(p.bis)}`, [{ name: "t", titel: "Bewegungen", art: "langtext" }], { t: text }, false);
}));
}
const RHYTHMEN: [string, string][] = [["monatlich", "monatlich"], ["vierteljaehrlich", "vierteljährlich"], ["jaehrlich", "jährlich"], ["einmalig", "einmalig"]];
const LK_FELDER: Feld[] = [
{ name: "bezeichnung", titel: "Bezeichnung", pflicht: true }, { name: "kategorie", titel: "Kategorie" },
{ name: "betrag", titel: "Betrag", art: "euro", pflicht: true }, { name: "rhythmus", titel: "Rhythmus", art: "auswahl", optionen: RHYTHMEN },
{ name: "start", titel: "Erste Zahlung", art: "datum", pflicht: true }, { name: "ende", titel: "Endet am", art: "datum" },
];
async function laufendeKosten(): Promise<void> {
const neu = async () => (await bearbeiten("laufende-kosten", "Neue laufende Kosten", LK_FELDER, null, { start: heute(), rhythmus: "monatlich" })) && laufendeKosten();
seite("Laufende Kosten", { text: "Neue Position", aktion: neu });
const zeilen = await api<Zeile[]>("laufende-kosten");
const r = Object.fromEntries(RHYTHMEN);
inhalt.appendChild(tabelle([
{ titel: "Kategorie", wert: (z) => esc(z.kategorie) }, { titel: "Bezeichnung", wert: (z) => esc(z.bezeichnung) },
{ titel: "Rhythmus", wert: (z) => esc(r[z.rhythmus]) }, { titel: "Ab", wert: (z) => dat(z.start), klasse: "optional" },
{ titel: "Betrag", wert: (z) => euro(z.betrag), klasse: "zahl" },
], zeilen, async (z) => (await bearbeiten("laufende-kosten", "Laufende Kosten bearbeiten", LK_FELDER, z)) && laufendeKosten()));
const monat = zeilen.filter((z) => z.rhythmus === "monatlich" && (!z.ende || z.ende >= heute())).reduce((s, z) => s + z.betrag, 0);
inhalt.insertAdjacentHTML("beforeend", `<p>Monatlich: <strong>${euro(monat)}</strong></p>`);
}
const AUFGABE_FELDER: Feld[] = [
{ name: "text", titel: "Aufgabe", pflicht: true }, { name: "faellig_am", titel: "Fällig am", art: "datum" },
];
function aufgabenTabelle(zeilen: Zeile[], neuLaden: () => void): HTMLTableElement {
const t = tabelle([
{ titel: "", wert: (z) => `<input type="checkbox" data-id="${z.id}"${z.erledigt_am ? " checked" : ""}>` },
{ titel: "Aufgabe", wert: (z) => (z.erledigt_am ? `<s>${esc(z.text)}</s>` : esc(z.text)) },
{ titel: "Fällig", wert: (z) => `<span class="${!z.erledigt_am && z.faellig_am && z.faellig_am < heute() ? "fehler" : ""}">${dat(z.faellig_am)}</span>` },
], zeilen, async (z) => (await bearbeiten("aufgaben", "Aufgabe bearbeiten", AUFGABE_FELDER, z)) && neuLaden());
t.addEventListener("click", async (ev) => {
const box = ev.target as HTMLInputElement;
if (box.type !== "checkbox") return;
ev.stopPropagation();
await api(`aufgaben/${box.dataset.id}`, "PATCH", { erledigt_am: box.checked ? new Date().toISOString() : null });
neuLaden();
}, true);
return t;
}
async function aufgaben(): Promise<void> {
const neu = async () => (await bearbeiten("aufgaben", "Neue Aufgabe", AUFGABE_FELDER, null)) && aufgaben();
seite("Aufgaben", { text: "Neue Aufgabe", aktion: neu });
inhalt.appendChild(aufgabenTabelle(await api<Zeile[]>("aufgaben"), aufgaben));
}
async function uebersicht(): Promise<void> {
seite("Übersicht");
const [alle, perioden] = await Promise.all([api<Zeile[]>("aufgaben"), api<Zeile[]>(`liquiditaet?ansicht=woche&anzahl=4&start=${heute()}`)]);
const bisSonntag = new Date(Date.now() + 7 * 86400000).toISOString().slice(0, 10);
const anstehend = alle.filter((a) => !a.erledigt_am && a.faellig_am && a.faellig_am <= bisSonntag);
inhalt.insertAdjacentHTML("beforeend", `<h2>Anstehende Aufgaben</h2>`);
inhalt.appendChild(anstehend.length ? aufgabenTabelle(anstehend, uebersicht) : Object.assign(document.createElement("p"), { className: "hinweis", textContent: "Nichts fällig in den nächsten 7 Tagen." }));
inhalt.insertAdjacentHTML("beforeend", `<h2>Liquidität 4 Wochen</h2>`);
inhalt.appendChild(tabelle([
{ titel: "Woche ab", wert: (p) => dat(p.von) },
{ titel: "Saldo", wert: (p) => euro(p.saldo), klasse: "zahl" },
{ titel: "Kontostand", wert: (p) => `<span class="${p.kontostand < 0 ? "fehler" : ""}">${euro(p.kontostand)}</span>`, klasse: "zahl" },
], perioden));
}
async function daten(): Promise<void> {
seite("Daten und Einstellungen");
const e = await api<Zeile>("einstellungen");
inhalt.insertAdjacentHTML("beforeend", `
<p><a class="neben" href="/api/export" download>Kompletten Stand als JSON sichern</a></p>
<p class="hinweis">Die Datenbank wird jede Nacht gesichert und in die Nextcloud kopiert. Der Import des V70-Stands folgt, sobald die V70-Datei vorliegt.</p>
<h2>Einstellungen</h2>`);
const felder: Feld[] = [
{ name: "startsaldo", titel: "Kontostand (Startsaldo)", art: "euro" },
{ name: "kundenTage", titel: "Zahlungsziel Kunden (Tage)", art: "zahl" },
{ name: "materialTage", titel: "Zahlungsziel Material (Tage)", art: "zahl" },
{ name: "fremdTage", titel: "Zahlungsziel Subunternehmer (Tage)", art: "zahl" },
{ name: "versteuerung", titel: "Umsatzsteuer nach", art: "auswahl", optionen: [["soll", "Soll (vereinbarte Entgelte)"], ["ist", "Ist (vereinnahmte Entgelte)"]] },
{ name: "voranmeldung", titel: "Voranmeldung", art: "auswahl", optionen: [["monatlich", "monatlich"], ["vierteljaehrlich", "vierteljährlich"]] },
{ name: "stundenProTag", titel: "Stunden pro Arbeitstag", art: "zahl" },
];
const knopf = document.createElement("button");
knopf.className = "neben";
knopf.textContent = "Einstellungen bearbeiten";
knopf.onclick = async () => {
const r = await dialog("Einstellungen", felder, { ...e, ...e.zahlungsziele, ...e.ust }, false);
if (r?.aktion !== "speichern") return;
const d = r.daten;
await api("einstellungen", "PUT", {
...e, startsaldo: d.startsaldo ?? 0, stundenProTag: d.stundenProTag ?? e.stundenProTag,
zahlungsziele: { ...e.zahlungsziele, kundenTage: d.kundenTage ?? 0, materialTage: d.materialTage ?? 0, fremdTage: d.fremdTage ?? 0 },
ust: { ...e.ust, versteuerung: d.versteuerung, voranmeldung: d.voranmeldung },
});
daten();
};
inhalt.appendChild(knopf);
}
const REITER: [string, string, () => Promise<void>][] = [
["uebersicht", "Übersicht", uebersicht], ["projekte", "Projekte", projekte], ["terminplan", "Terminplan", terminplan],
["liquiditaet", "Liquidität", () => liquiditaetSeite()], ["laufende-kosten", "Laufende Kosten", laufendeKosten],
["kontakte", "Kontakte", kontakte], ["aufgaben", "Aufgaben", aufgaben], ["daten", "Daten", daten],
];
const nav = document.getElementById("reiter")!;
nav.innerHTML = REITER.map(([id, titel]) => `<button data-r="${id}">${titel}</button>`).join("");
nav.addEventListener("click", (ev) => {
const r = (ev.target as HTMLElement).dataset.r;
if (r) location.hash = r;
});
async function zeige(): Promise<void> {
const id = location.hash.slice(1) || "uebersicht";
const reiter = REITER.find(([r]) => r === id) ?? REITER[0]!;
nav.querySelectorAll("button").forEach((b) => b.classList.toggle("aktiv", b.dataset.r === reiter[0]));
try {
await reiter[2]();
} catch (e) {
inhalt.insertAdjacentHTML("beforeend", `<p class="fehler">${esc((e as Error).message)}</p>`);
}
}
window.addEventListener("hashchange", zeige);
window.addEventListener("unhandledrejection", (ev) => {
inhalt.insertAdjacentHTML("afterbegin", `<p class="fehler">${esc(ev.reason?.message ?? ev.reason)}</p>`);
});
zeige();
api("status").then((s) => (document.getElementById("version")!.textContent = `Version ${s.version}`)).catch(() => {});

19
src/web/index.html Normal file
View File

@@ -0,0 +1,19 @@
<!doctype html>
<html lang="de">
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>Betrieb · Schaarschmidt Holzbau</title>
<link rel="stylesheet" href="/styles.css">
</head>
<body>
<header>
<strong>Schaarschmidt Holzbau</strong>
<nav id="reiter"></nav>
<span id="version"></span>
</header>
<main id="inhalt"></main>
<div id="dialog-huelle" hidden></div>
<script type="module" src="/app.js"></script>
</body>
</html>

37
src/web/styles.css Normal file
View File

@@ -0,0 +1,37 @@
:root {
--bg: #f6f5f2; --fl: #ffffff; --text: #1f1f1d; --leise: #6b6a65; --linie: #dedcd5;
--akzent: #8a4b14; --akzent-text: #ffffff; --warn: #b42318;
font-family: system-ui, -apple-system, "Segoe UI", sans-serif; font-size: 15px;
}
@media (prefers-color-scheme: dark) {
:root { --bg: #1b1b1a; --fl: #262624; --text: #ecebe6; --leise: #a3a29b; --linie: #3a3936; --akzent: #d9893f; --akzent-text: #1b1b1a; --warn: #f97066; }
}
* { box-sizing: border-box; }
body { margin: 0; background: var(--bg); color: var(--text); }
header { display: flex; gap: 16px; align-items: center; flex-wrap: wrap; padding: 10px 16px; background: var(--fl); border-bottom: 1px solid var(--linie); }
header nav { display: flex; gap: 4px; flex-wrap: wrap; flex: 1; }
header nav button { background: none; border: 0; padding: 6px 10px; border-radius: 6px; color: var(--leise); cursor: pointer; font: inherit; }
header nav button.aktiv { background: var(--bg); color: var(--text); font-weight: 600; }
#version { color: var(--leise); font-size: 12px; }
main { padding: 16px; max-width: 1200px; margin: 0 auto; }
h1 { font-size: 20px; margin: 4px 0 16px; }
.leiste { display: flex; gap: 8px; margin-bottom: 12px; align-items: center; }
button.haupt { background: var(--akzent); color: var(--akzent-text); border: 0; border-radius: 6px; padding: 7px 14px; font: inherit; cursor: pointer; }
button.neben { background: var(--fl); color: var(--text); border: 1px solid var(--linie); border-radius: 6px; padding: 6px 12px; font: inherit; cursor: pointer; }
table { width: 100%; border-collapse: collapse; background: var(--fl); border: 1px solid var(--linie); border-radius: 8px; overflow: hidden; }
th, td { text-align: left; padding: 7px 10px; border-bottom: 1px solid var(--linie); }
th { font-size: 12px; color: var(--leise); font-weight: 600; }
td.zahl, th.zahl { text-align: right; font-variant-numeric: tabular-nums; }
tr.klickbar { cursor: pointer; }
tr.klickbar:hover td { background: var(--bg); }
.hinweis { color: var(--leise); }
.fehler { color: var(--warn); }
#dialog-huelle { position: fixed; inset: 0; background: rgb(0 0 0 / 0.35); display: grid; place-items: center; padding: 16px; }
#dialog-huelle[hidden] { display: none; }
.dialog { background: var(--fl); border-radius: 10px; padding: 18px; width: min(460px, 100%); box-shadow: 0 10px 30px rgb(0 0 0 / 0.25); }
.dialog h2 { font-size: 17px; margin: 0 0 12px; }
.dialog label { display: block; font-size: 12px; color: var(--leise); margin: 10px 0 3px; }
.dialog input, .dialog select, .dialog textarea { width: 100%; padding: 7px 8px; border: 1px solid var(--linie); border-radius: 6px; background: var(--bg); color: var(--text); font: inherit; }
.dialog .knoepfe { display: flex; justify-content: flex-end; gap: 8px; margin-top: 16px; }
.dialog .knoepfe .links { margin-right: auto; }
@media (max-width: 640px) { th.optional, td.optional { display: none; } }