Files
Betriebsf-hrungssoftware/src/web/mengenblatt.ts
Claude 8d0f88a9fa
Some checks failed
Prüfung / tests (push) Has been cancelled
Prüfung / container (push) Has been cancelled
0.30.1: Wandliste in der Position bearbeitbar, Fassade aus der Wandliste
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01AmyPfuNc4sCRfaF3oURXZz
2026-10-22 13:02:17 +00:00

411 lines
33 KiB
TypeScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
// Mengenblatt und Vorlagen (neue Angebotsmaske, Henning 21.10.2026, Bilder 3 bis 6): dieselbe Darstellung für das
// Aufmaß in der Position, das große Mengenblatt und den Vorlagen-Editor. Eingaben sind gelb, Formeln blau.
// Felder tragen data-k = Präfix + Pfad im Blatt (z. B. „blatt:<id>:werte.2.formel“); die Seite speichert.
import { benenneUm, FUNKTIONEN, zahlDeutsch } from "../domain/formel.js";
import { type Auswertung, type Blatt, alsBlatt, werteBlatt } from "../domain/mengenblatt.js";
import { type Ansatz, type Mengenvorlage } from "../domain/mengenvorlagen.js";
import { formatEuro, parseEuro } from "../domain/geld.js";
import { KOSTENARTEN, KOSTENART_NAME, VORLAGE_LOHNARTEN, lohnartOptionen, umgebungVon } from "../domain/kalkulation.js";
import { type Zeile, api, bestaetigen, dialog, esc, hinweis, inhalt, istHandy, optionenHtml } from "./ui.js";
export const zahlText = (v: unknown) => (v === null || v === undefined || v === "" ? "" : String(Number(v)).replace(".", ","));
export const zahlAus = (t: string) => {
const n = Number(t.trim().replace(/\./g, "").replace(",", "."));
if (!Number.isFinite(n)) throw new Error(`„${t}“ ist keine Zahl`);
return n;
};
const ergebnisText = (v: unknown, einheit?: string | null) => (typeof v === "number" ? zahlDeutsch(v, einheit) : v === null || v === undefined ? "" : esc(v));
// ---------- Ändern ----------
/** Wert an einen Pfad wie „listen.0.zeilen.3.Breite“ schreiben; ein neues Kürzel wird in allen Formeln nachgezogen */
export function setze(blatt: Blatt & { ansaetze?: Ansatz[] }, pfad: string, wert: string): string[] {
const teile = pfad.split(".");
const umbenannt: string[] = [];
const kz = /^werte\.(\d+)\.kz$/.exec(pfad);
if (kz) {
const alt = blatt.werte[Number(kz[1])]?.kz ?? "";
if (alt && wert && alt !== wert) { benenneImBlatt(blatt, (f) => benenneUm(f, alt, wert)); umbenannt.push(alt, wert); }
}
const lkz = /^listen\.(\d+)\.kz$/.exec(pfad);
if (lkz) {
const alt = blatt.listen[Number(lkz[1])]?.kz ?? "";
if (alt && wert && alt !== wert) benenneImBlatt(blatt, (f) => f.replace(new RegExp(`(?<![\\p{L}\\p{N}_.])${alt}\\.`, "gu"), `${wert}.`));
}
const skz = /^listen\.(\d+)\.spalten\.(\d+)\.kz$/.exec(pfad);
if (skz) {
const l = blatt.listen[Number(skz[1])]!, alt = l.spalten[Number(skz[2])]?.kz ?? "";
if (alt && wert && alt !== wert) {
for (const s of l.spalten) if (s.formel) s.formel = benenneUm(s.formel, alt, wert);
for (const z of l.zeilen) {
if (alt in z) { z[wert] = z[alt]!; delete z[alt]; }
for (const k of Object.keys(z)) z[k] = benenneUm(z[k]!, alt, wert);
}
benenneImBlatt(blatt, (f) => f.replaceAll(`${l.kz}.${alt}`, `${l.kz}.${wert}`));
}
}
const typ = /^listen\.(\d+)\.spalten\.(\d+)\.typ$/.exec(pfad);
if (typ) {
const s = blatt.listen[Number(typ[1])]!.spalten[Number(typ[2])]!;
s.art = wert === "text" ? "text" : "zahl";
s.formel = wert === "formel" ? s.formel ?? "" : null;
return umbenannt;
}
let o: any = blatt;
for (const t of teile.slice(0, -1)) o = o[t] ??= {};
const letzter = teile.at(-1)!;
if (wert === "" && /^listen\.\d+\.zeilen\.\d+\./.test(pfad)) delete o[letzter];
else o[letzter] = wert;
return umbenannt;
}
function benenneImBlatt(b: Blatt & { ansaetze?: Ansatz[] }, f: (formel: string) => string): void {
for (const w of b.werte) w.formel = f(w.formel);
for (const l of b.listen) {
for (const s of l.spalten) if (s.formel) s.formel = f(s.formel);
for (const z of l.zeilen) for (const k of Object.keys(z)) z[k] = f(z[k]!);
}
for (const z of b.zeilen) z.formel = f(z.formel);
if (b.menge) b.menge = f(b.menge);
for (const a of b.ansaetze ?? []) if (a.bezug) a.bezug = f(a.bezug);
}
const freiesKuerzel = (b: Blatt, basis: string) => {
const da = new Set(b.werte.map((w) => w.kz));
for (let i = 1; ; i++) if (!da.has(`${basis}${i}`)) return `${basis}${i}`;
};
/** Zeilen anlegen und löschen (data-a beginnt mit „b-“); true, wenn sich etwas geändert hat */
export function blattAktion(b: Blatt & { ansaetze?: Ansatz[] }, a: string, d: DOMStringMap): boolean {
const i = Number(d.i), l = Number(d.l);
switch (a) {
case "b-wert-neu": b.werte.push(d.was === "formel" ? { kz: freiesKuerzel(b, "F"), bez: "", einheit: "", formel: "" } : { kz: freiesKuerzel(b, "E"), bez: "", einheit: "m", formel: "0", eingabe: true }); return true;
case "b-wert-weg": b.werte.splice(i, 1); return true;
case "b-zeile-neu": b.zeilen.push({ text: "", formel: "" }); return true;
case "b-zeile-weg": b.zeilen.splice(i, 1); return true;
case "b-lzeile-neu": b.listen[l]!.zeilen.push({}); return true;
case "b-lzeile-weg": b.listen[l]!.zeilen.splice(i, 1); return true;
case "b-liste-neu": {
const da = new Set(b.listen.map((x) => x.kz));
let n = 1;
while (da.has(`L${n}`)) n++;
b.listen.push({ kz: `L${n}`, name: "Liste", spalten: [{ kz: "Bezeichnung", bez: "Bezeichnung", art: "text" }, { kz: "Länge", bez: "Länge", einheit: "m" },
{ kz: "Anzahl", bez: "Anzahl", einheit: "St" }, { kz: "Summe", bez: "Summe", einheit: "m", formel: "Länge * Anzahl" }], zeilen: [{}] });
return true;
}
case "b-liste-weg": b.listen.splice(l, 1); return true;
case "b-spalte-neu": {
const da = new Set(b.listen[l]!.spalten.map((x) => x.kz));
let n = 1;
while (da.has(`S${n}`)) n++;
b.listen[l]!.spalten.push({ kz: `S${n}`, bez: "", einheit: "" });
return true;
}
case "b-spalte-weg": b.listen[l]!.spalten.splice(i, 1); return true;
}
return false;
}
// ---------- Darstellung ----------
export interface BlattOptionen {
/** Präfix der data-k-Schlüssel, z. B. „blatt:<id>:“ */
k: string;
frei: boolean;
/** inline: in der Position; gross: Mengenblatt; vorlage: Vorlagen-Editor mit Spalten */
modus: "inline" | "gross" | "vorlage";
einheit?: string | null;
}
const feld = (k: string, wert: unknown, o: { klasse?: string; titel?: string; platz?: string; frei: boolean; liste?: string; fehler?: string | null }) =>
`<input data-k="${esc(k)}" data-typ="roh" value="${esc(wert ?? "")}" class="${o.klasse ?? ""}${o.fehler ? " mit-fehler" : ""}"${o.titel ? ` aria-label="${esc(o.titel)}"` : ""}${o.platz ? ` placeholder="${esc(o.platz)}"` : ""}${o.liste ? ` list="${o.liste}"` : ""}${o.fehler ? ` title="${esc(o.fehler)}"` : ""}${o.frei ? "" : " disabled"}>`;
const weg = (a: string, k: string, extra: string, frei: boolean, titel: string) =>
frei ? `<button class="weg" data-a="${a}" data-b="${esc(k)}" ${extra} title="${titel}" aria-label="${titel}">×</button>` : "";
const fehlerZelle = (f: string | undefined) => (f ? `<span class="am-fehler">${esc(f)}</span>` : "");
/** Kürzel des Blatts als Vorschlagsliste für Formeln */
export function kuerzelListe(id: string, b: Blatt): string {
const kz = [...b.werte.map((w) => [w.kz, w.bez ?? ""]), ...b.listen.flatMap((l) => l.spalten.map((s) => [`${l.kz}.${s.kz}`, `${l.name ?? l.kz}: ${s.bez ?? s.kz}`]))];
return `<datalist id="${id}">${kz.filter(([k]) => k).map(([k, t]) => `<option value="${esc(k)}">${esc(t)}</option>`).join("")}</datalist>`;
}
function werteTabelle(b: Blatt, a: Auswertung, o: BlattOptionen, nur?: "eingabe" | "formel"): string {
const zeilen = b.werte.map((w, i) => [w, i] as const).filter(([w]) => !nur || (nur === "eingabe") === !!w.eingabe);
const vorlage = o.modus === "vorlage";
const kopf = vorlage && nur === "eingabe" ? "<th>Kürzel</th><th>Bezeichnung</th><th>Einheit</th><th>Beispiel</th><th></th>"
: `<th>Kürzel</th><th>Bezeichnung</th><th>${nur === "formel" ? "Formel" : "Wert / Formel"}</th><th class="zahl">${vorlage ? "Probe" : "Ergebnis"}</th>${vorlage ? "" : "<th>Einheit</th>"}<th></th>`;
const rumpf = zeilen.map(([w, i]) => {
const f = a.fehler[`w:${i}`];
const wertFeld = feld(`${o.k}werte.${i}.formel`, w.formel, { klasse: w.eingabe ? "am-eingabe zahl" : "am-formel", titel: `${w.kz} Wert`, frei: o.frei, fehler: f, liste: "am-kuerzel" });
const kzFeld = feld(`${o.k}werte.${i}.kz`, w.kz, { klasse: "am-kz", titel: "Kürzel", frei: o.frei });
const bezFeld = feld(`${o.k}werte.${i}.bez`, w.bez, { titel: "Bezeichnung", frei: o.frei, platz: "Bezeichnung" });
const einheitFeld = feld(`${o.k}werte.${i}.einheit`, w.einheit, { klasse: "w-kurz", titel: "Einheit", frei: o.frei, liste: "einheiten" });
const loeschen = weg("b-wert-weg", o.k, `data-i="${i}"`, o.frei, "Zeile löschen");
if (vorlage && nur === "eingabe") return `<tr><td>${kzFeld}</td><td>${bezFeld}</td><td>${einheitFeld}</td><td>${wertFeld}${fehlerZelle(f)}</td><td>${loeschen}</td></tr>`;
return `<tr><td>${kzFeld}</td><td>${bezFeld}</td><td>${wertFeld}${fehlerZelle(f)}</td><td class="zahl"><b>${f ? "–" : ergebnisText(a.ergebnis[`w:${i}`], w.einheit)}</b></td>${vorlage ? "" : `<td>${einheitFeld}</td>`}<td>${loeschen}</td></tr>`;
}).join("");
return `<div class="tabelle-rolle"><table class="am-t"><thead><tr>${kopf}</tr></thead><tbody>${rumpf || `<tr><td colspan="6" class="hinweis">${nur === "formel" ? "Noch keine Formel." : "Noch keine Eingabe."}</td></tr>`}</tbody></table></div>`;
}
function listeHtml(b: Blatt, a: Auswertung, o: BlattOptionen, li: number): string {
const l = b.listen[li]!;
// Henning, 22.10.2026: Wandmaße auch direkt in der Position ändern, wie in den anderen Tabellen
const lesen = !o.frei;
const kopf = l.spalten.map((s) => `<th class="${s.art === "text" ? "" : "zahl"}">${esc(s.bez || s.kz)}${s.einheit ? ` <small>[${esc(s.einheit)}]</small>` : ""}</th>`).join("");
const zeilen = l.zeilen.map((z, zi) => `<tr>${l.spalten.map((s) => {
const sch = `l:${li}:${zi}:${s.kz}`, f = a.fehler[sch];
if (s.formel || lesen) return `<td class="${s.art === "text" ? "" : "zahl"}">${f ? `<span class="am-fehler" title="${esc(f)}">Fehler</span>` : s.formel ? `<b>${ergebnisText(a.ergebnis[sch], s.einheit)}</b>` : ergebnisText(a.ergebnis[sch], s.einheit)}</td>`;
return `<td>${feld(`${o.k}listen.${li}.zeilen.${zi}.${s.kz}`, z[s.kz] ?? "", { klasse: s.art === "text" ? "am-eingabe" : "am-eingabe zahl", titel: `${s.bez || s.kz}, Zeile ${zi + 1}`, frei: o.frei, fehler: f, liste: s.art === "text" ? undefined : "am-kuerzel" })}</td>`;
}).join("")}${lesen ? "" : `<td>${weg("b-lzeile-weg", o.k, `data-l="${li}" data-i="${zi}"`, o.frei, "Zeile löschen")}</td>`}</tr>`).join("");
const summen = l.spalten.map((s) => {
if (s.art === "text" || !s.formel) return "<td></td>";
const v = l.zeilen.reduce((t, _, zi) => t + (typeof a.ergebnis[`l:${li}:${zi}:${s.kz}`] === "number" ? (a.ergebnis[`l:${li}:${zi}:${s.kz}`] as number) : 0), 0);
return `<td class="zahl">${zahlDeutsch(v, s.einheit)}</td>`;
});
summen[0] = "<td>Summe</td>";
const spalten = o.modus === "vorlage" ? `<details class="am-spalten"${l.spalten.length ? "" : " open"}><summary>Spalten der Liste festlegen</summary>
<div class="tabelle-rolle"><table class="am-t"><thead><tr><th>Kürzel</th><th>Bezeichnung</th><th>Einheit</th><th>Art</th><th>Formel (berechnet)</th><th></th></tr></thead><tbody>
${l.spalten.map((s, si) => `<tr><td>${feld(`${o.k}listen.${li}.spalten.${si}.kz`, s.kz, { klasse: "am-kz", titel: "Kürzel der Spalte", frei: o.frei })}</td>
<td>${feld(`${o.k}listen.${li}.spalten.${si}.bez`, s.bez, { titel: "Bezeichnung", frei: o.frei })}</td>
<td>${feld(`${o.k}listen.${li}.spalten.${si}.einheit`, s.einheit, { klasse: "w-kurz", titel: "Einheit", frei: o.frei, liste: "einheiten" })}</td>
<td><select data-k="${esc(`${o.k}listen.${li}.spalten.${si}.typ`)}" data-typ="roh" aria-label="Art der Spalte"${o.frei ? "" : " disabled"}>${optionenHtml([["text", "Eingabe Text"], ["zahl", "Eingabe Zahl"], ["formel", "berechnet"]], s.formel !== null && s.formel !== undefined ? "formel" : s.art === "text" ? "text" : "zahl")}</select></td>
<td>${s.formel !== null && s.formel !== undefined ? feld(`${o.k}listen.${li}.spalten.${si}.formel`, s.formel, { klasse: "am-formel", titel: "Formel", frei: o.frei, platz: "z. B. Länge * Anzahl" }) : ""}</td>
<td>${weg("b-spalte-weg", o.k, `data-l="${li}" data-i="${si}"`, o.frei, "Spalte löschen")}</td></tr>`).join("")}</tbody></table></div>
${o.frei ? `<button class="neben klein" data-a="b-spalte-neu" data-b="${esc(o.k)}" data-l="${li}">+ Spalte</button>` : ""}
<p class="hinweis-k">Berechnete Spalten rechnen mit den Kürzeln der Spalten dieser Zeile. Summen bildest du mit summe(${esc(l.kz)}.Spalte) oder summewenn(${esc(l.kz)}.Spalte; ${esc(l.kz)}.Kennung; "W").</p></details>` : "";
return `<div class="am-liste"><h4 class="am-zwischen">${o.modus === "vorlage" ? `${feld(`${o.k}listen.${li}.name`, l.name, { titel: "Name der Liste", frei: o.frei, klasse: "am-listenname" })} <span class="hinweis">Kürzel</span> ${feld(`${o.k}listen.${li}.kz`, l.kz, { klasse: "am-kz", titel: "Kürzel der Liste", frei: o.frei })}${weg("b-liste-weg", o.k, `data-l="${li}"`, o.frei, "Liste löschen")}` : `${esc(l.name || l.kz)} <span class="hinweis">(${esc(l.kz)})</span>`}</h4>
${spalten}
<div class="tabelle-rolle"><table class="am-t"><thead><tr>${kopf}${lesen ? "" : "<th></th>"}</tr></thead><tbody>${zeilen}<tr class="summe">${summen.join("")}${lesen ? "" : "<td></td>"}</tr></tbody></table></div>
${!lesen && o.frei ? `<div class="knopfreihe"><button class="neben klein" data-a="b-lzeile-neu" data-b="${esc(o.k)}" data-l="${li}">+ Zeile</button></div>` : ""}</div>`;
}
/** freie Aufmaßzeilen wie in Plancraft: Beschreibung, Formel, Ergebnis (Bild 5) */
export function aufmassZeilenHtml(b: Blatt, a: Auswertung, o: BlattOptionen): string {
const zeilen = b.zeilen.map((z, i) => {
const f = a.fehler[`z:${i}`];
return `<tr><td>${feld(`${o.k}zeilen.${i}.text`, z.text, { titel: `Beschreibung Zeile ${i + 1}`, frei: o.frei, platz: i === 0 ? "z. B. Wand links" : "" })}</td>
<td>${feld(`${o.k}zeilen.${i}.formel`, z.formel, { klasse: "am-formel", titel: `Formel Zeile ${i + 1}`, frei: o.frei, fehler: f, platz: i === 0 ? "z. B. 100+(5,1*4)/2" : "", liste: "am-kuerzel" })}${fehlerZelle(f)}</td>
<td class="zahl"><b>${f ? "–" : ergebnisText(a.ergebnis[`z:${i}`], o.einheit)}</b></td><td>${weg("b-zeile-weg", o.k, `data-i="${i}"`, o.frei, "Zeile löschen")}</td></tr>`;
}).join("");
const summeMenge = !b.menge?.trim();
return `<div class="tabelle-rolle"><table class="am-t am-aufmass"><thead><tr><th>Beschreibung</th><th>Formel</th><th class="zahl">Ergebnis</th><th></th></tr></thead><tbody>${zeilen}
<tr class="summe"><td colspan="2">${summeMenge ? "Summe → Menge der Position" : "Summe der Aufmaßzeilen"}</td><td class="zahl">${zahlDeutsch(a.summeZeilen, o.einheit)}</td><td></td></tr></tbody></table></div>`;
}
function mengeWahl(b: Blatt, a: Auswertung, o: BlattOptionen): string {
return `<div class="menge-wahl"><span>Menge der Position</span>${feld(`${o.k}menge`, b.menge, { klasse: "am-formel am-menge", titel: "Menge der Position (Kürzel oder Formel)", frei: o.frei, platz: "Summe der Aufmaßzeilen", liste: "am-kuerzel", fehler: a.fehler.menge })}
<span>= <b>${a.menge === null ? "–" : `${zahlDeutsch(a.menge, o.einheit)} ${esc(o.einheit ?? "")}`}</b></span>${fehlerZelle(a.fehler.menge)}</div>`;
}
const legende = `<div class="legende"><span><i class="am-l-eingabe"></i>Eingabe</span><span><i class="am-l-formel"></i>Formel mit Kürzeln, z. B. (B/2+UET)/cos(DN)</span>
<span>Erlaubt: + − * / ^ ( ), ${FUNKTIONEN.slice(0, 12).join(", ")} …; Argumente mit Semikolon trennen, Winkel in Grad.</span></div>`;
/** Inhalt des Mengenblatts für die drei Ansichten */
export function blattHtml(b: Blatt, a: Auswertung, o: BlattOptionen): string {
const mitVorlage = b.werte.length > 0 || b.listen.length > 0;
if (o.modus === "inline") {
const formeln = b.werte.map((w, i) => [w, i] as const).filter(([w, i]) => !w.eingabe && typeof a.ergebnis[`w:${i}`] === "number").slice(0, 8);
const fehler = Object.keys(a.fehler).filter((k) => k !== "menge" && !k.startsWith("z:")).length;
return `${mitVorlage ? `<div class="am-vorlage-info">${b.vorlage ? `Vorlage <b>${esc(b.vorlage.name)}</b>` : "Mengenblatt"}
${formeln.map(([w, i]) => `<span class="am-erg"><span class="am-kz-t">${esc(w.kz)}</span> ${zahlDeutsch(a.ergebnis[`w:${i}`] as number, w.einheit)} ${esc(w.einheit ?? "")}</span>`).join("")}
${fehler ? `<span class="am-fehler">${fehler} Fehler im Mengenblatt</span>` : ""}</div>
${b.werte.some((w) => w.eingabe) ? `<div class="am-eingaben-kurz">${b.werte.map((w, i) => [w, i] as const).filter(([w]) => w.eingabe).map(([w, i]) => `<label><span><span class="am-kz-t">${esc(w.kz)}</span> ${esc(w.bez ?? "")}</span>${feld(`${o.k}werte.${i}.formel`, w.formel, { klasse: "am-eingabe zahl", titel: `${w.kz} ${w.bez ?? ""}`, frei: o.frei, fehler: a.fehler[`w:${i}`], liste: "am-kuerzel" })}</label>`).join("")}</div>` : ""}
${b.listen.map((_, li) => listeHtml(b, a, o, li)).join("")}` : ""}
${b.zeilen.length || !mitVorlage ? aufmassZeilenHtml(b, a, o) : ""}
${mitVorlage ? mengeWahl(b, a, o) : ""}`;
}
if (o.modus === "gross") {
const formeln = b.werte.map((w, i) => [w, i] as const).filter(([w]) => !w.eingabe);
return `<div class="zwei"><div><h3 class="am-h">Grunddaten und Formeln</h3>${werteTabelle(b, a, o)}
${o.frei ? `<div class="knopfreihe"><button class="neben klein" data-a="b-wert-neu" data-b="${esc(o.k)}" data-was="eingabe">+ Eingabe</button><button class="neben klein" data-a="b-wert-neu" data-b="${esc(o.k)}" data-was="formel">+ Formel</button></div>` : ""}</div>
<div><h3 class="am-h">Ergebnisse</h3><div class="erg">${formeln.map(([w, i]) => `<span class="am-kz-t">${esc(w.kz)}</span><span>${esc(w.bez ?? "")}</span><span class="w">${a.fehler[`w:${i}`] ? '<span class="am-fehler">Fehler</span>' : ergebnisText(a.ergebnis[`w:${i}`], w.einheit)}</span><span>${esc(w.einheit ?? "")}</span>`).join("") || '<span class="hinweis">Noch keine Formel.</span>'}</div>
${mengeWahl(b, a, o)}</div></div>
${b.listen.map((_, li) => listeHtml(b, a, o, li)).join("")}
<h3 class="am-h">Aufmaßzeilen</h3>${aufmassZeilenHtml(b, a, o)}
${o.frei ? `<div class="knopfreihe"><button class="neben klein" data-a="b-zeile-neu" data-b="${esc(o.k)}">+ Aufmaßzeile</button></div>` : ""}${legende}`;
}
return `<div class="zwei am-zwei-v"><div><h3 class="am-h">1 Eingaben <span class="hinweis-k">fragt das Programm beim Einfügen ab</span></h3>${werteTabelle(b, a, o, "eingabe")}
${o.frei ? `<div class="knopfreihe"><button class="neben klein" data-a="b-wert-neu" data-b="${esc(o.k)}" data-was="eingabe">+ Eingabe</button><button class="neben klein" data-a="b-liste-neu" data-b="${esc(o.k)}">+ Liste (wie W/F/G)</button></div>` : ""}</div>
<div><h3 class="am-h">2 Formeln <span class="hinweis-k">rechnen mit den Kürzeln</span></h3>${werteTabelle(b, a, o, "formel")}
${o.frei ? `<div class="knopfreihe"><button class="neben klein" data-a="b-wert-neu" data-b="${esc(o.k)}" data-was="formel">+ Formel</button></div>` : ""}</div></div>
${b.listen.map((_, li) => listeHtml(b, a, o, li)).join("")}
${legende}
<div class="am-schritt3"><b>3</b> ${mengeWahl(b, a, o)}</div>`;
}
// ---------- Vorlagen auswählen und einfügen ----------
let vorlagenSpeicher: Mengenvorlage[] | null = null;
export async function alleVorlagen(neu = false): Promise<Mengenvorlage[]> {
if (!vorlagenSpeicher || neu) vorlagenSpeicher = await api<Mengenvorlage[]>("mengenvorlagen-alle");
return vorlagenSpeicher;
}
/** Liste in der Seitenleiste: Musterpositionen (art muster) oder Mengenvorlagen, nach Gruppen, mit Suche */
export function vorlagenListeHtml(liste: Mengenvorlage[], o: { art: "muster" | "mengen" | "alle"; suche: string; ziel?: string | null; frei: boolean }): string {
const s = o.suche.trim().toLowerCase();
// eine kopierte und geänderte Vorlage mit gleichem Namen ersetzt die mitgelieferte im Katalog
const eigeneNamen = new Set(liste.filter((v) => !v.fest).map((v) => `${v.gruppe}|${v.name}`));
const passend = liste.filter((v) => !(v.fest && o.art !== "alle" && eigeneNamen.has(`${v.gruppe}|${v.name}`)))
.filter((v) => (o.art === "alle" || v.art === o.art || (o.art === "mengen" && v.art === "muster" && (v.inhalt.werte.length || v.inhalt.listen.length)))
&& (!s || `${v.name} ${v.gruppe} ${v.beschreibung ?? ""} ${v.kurztext ?? ""}`.toLowerCase().includes(s)));
const gruppen = [...new Set(passend.map((v) => v.gruppe))];
if (!passend.length) return `<p class="hinweis-k">${s ? "Nichts gefunden." : "Noch keine Vorlage."}</p>`;
return gruppen.map((g) => `<div class="gr">${esc(g)}</div>${passend.filter((v) => v.gruppe === g).map((v) => `<div class="baustein"${o.frei ? ` draggable="true" data-zieh="vorlage:${esc(v.id)}"` : ""}>
<span class="g" aria-hidden="true">⋮⋮</span><span class="am-b-text">${esc(v.name)}${v.beschreibung ? `<small>${esc(v.beschreibung)}</small>` : ""}</span>
${o.frei ? `<button class="plus" data-a="vorlage" data-id="${esc(v.id)}"${o.ziel ? ` data-in="${esc(o.ziel)}"` : ""} title="${o.ziel ? "In das Mengenblatt einfügen" : "Unter der markierten Zeile einfügen"}" aria-label="${esc(v.name)} einfügen">+</button>` : ""}
<a class="am-b-bearb" href="#${v.art === "muster" ? "leistung" : "vorlage"}-${esc(v.id)}" title="${v.fest ? "Ansehen und kopieren" : "Bearbeiten"}" aria-label="${esc(v.name)} ${v.fest ? "ansehen" : "bearbeiten"}">✎</a></div>`).join("")}`).join("");
}
/** Eingaben einer Vorlage beim Einfügen abfragen (Bild 6: „fragt das Programm beim Einfügen ab“) */
export async function eingabenAbfragen(v: Mengenvorlage): Promise<Record<string, string> | null> {
const eingaben = v.inhalt.werte.filter((w) => w.eingabe);
if (!eingaben.length) return {};
const r = await dialog(`${v.name} einfügen`, eingaben.map((w, i) => ({
name: `e${i}`, titel: `${w.kz}: ${w.bez || w.kz}${w.einheit ? ` [${w.einheit}]` : ""}`, art: "text" as const,
...(i === eingaben.length - 1 ? { hilfe: "Vorbelegt mit den Beispielwerten der Vorlage. Alles lässt sich später im Mengenblatt ändern." } : {}),
})), Object.fromEntries(eingaben.map((w, i) => [`e${i}`, w.formel])), false);
if (r?.aktion !== "speichern") return null;
return Object.fromEntries(eingaben.map((w, i) => [w.kz, String(r.daten[`e${i}`] ?? w.formel)]));
}
// ---------- Vorlagen-Editor (Bild 6) ----------
const ANSATZ_ARTEN = KOSTENARTEN.map((x): [string, string] => [x, KOSTENART_NAME[x]]);
function ansaetzeHtml(v: Mengenvorlage, a: Auswertung, frei: boolean): string {
const rumpf = v.inhalt.ansaetze.map((z, i) => {
const lohn = z.kostenart === "lohn";
let probe = "–", fehler: string | null = null;
try {
const bezug = z.bezug?.trim() ? a.rechne(z.bezug) : a.menge ?? 0;
probe = `${zahlDeutsch(bezug * Number(z.menge) * Number(z.personen ?? 1) * (lohn ? 1 : Number(z.faktor ?? 1)), lohn ? "h" : z.einheit)} ${lohn ? "h" : esc(z.einheit ?? "")}`;
} catch (e) { fehler = (e as Error).message; }
const k = (f: string) => `vb:ansaetze.${i}.${f}`;
return `<tr class="kz-${z.kostenart}${z.aktiv === false ? " aus" : ""}"><td><select data-k="${k("kostenart")}" data-typ="roh" aria-label="Art"${frei ? "" : " disabled"}>${optionenHtml(ANSATZ_ARTEN, z.kostenart)}</select></td>
<td class="kz-text">${lohn ? `<select data-k="${k("lohnart")}" data-typ="roh" aria-label="Lohnart"${frei ? "" : " disabled"}>${optionenHtml(lohnartOptionen(VORLAGE_LOHNARTEN, z.lohnart), z.lohnart ?? "geselle")}</select>` : ""}${feld(k("beschreibung"), z.beschreibung, { titel: "Tätigkeit / Material", frei, platz: lohn ? "Tätigkeit" : "Material" })}</td>
<td>${feld(k("bezug"), z.bezug, { klasse: "am-formel", titel: "Bezug", frei, platz: "Menge", liste: "am-kuerzel", fehler })}</td>
<td>${feld(k("menge"), zahlText(z.menge), { klasse: "am-eingabe zahl w-menge", titel: lohn ? "Std je Einheit des Bezugs" : "Menge je Einheit des Bezugs", frei })}</td>
<td>${lohn ? feld(k("personen"), zahlText(z.personen ?? 1), { klasse: "am-eingabe zahl w-kurz", titel: "Personen", frei }) : feld(k("faktor"), zahlText(z.faktor ?? 1), { klasse: "zahl w-kurz", titel: "Faktor", frei })}</td>
<td>${lohn ? '<span class="hinweis">h</span>' : feld(k("einheit"), z.einheit, { klasse: "w-kurz", titel: "Einheit", frei, liste: "einheiten" })}</td>
<td>${feld(k("ek"), z.ek == null ? "" : formatEuro(z.ek, false), { klasse: "zahl w-euro", titel: "EK", frei, platz: lohn ? "Satz" : "0,00" })}</td>
<td class="zahl"><b>${probe}</b></td>
<td><input type="checkbox" data-k="${k("aktiv")}" data-typ="bool" ${z.aktiv === false ? "" : "checked"} aria-label="notwendig"${frei ? "" : " disabled"}></td>
<td>${frei ? `<button class="weg" data-a="v-ansatz-weg" data-i="${i}" title="Zeile löschen" aria-label="Zeile löschen">×</button>` : ""}</td></tr>`;
}).join("");
return `<div class="tabelle-rolle"><table class="am-t kosten-tabelle"><thead><tr><th>Art</th><th>Tätigkeit / Material</th><th>Bezug</th><th class="zahl">Ansatz</th><th class="zahl">Pers. / Faktor</th><th>Einheit</th><th class="zahl">EK</th><th class="zahl">Probe</th><th title="notwendig">✓</th><th></th></tr></thead>
<tbody>${rumpf || '<tr><td colspan="10" class="hinweis">Noch keine Zeitansätze. Ohne sie bleibt es eine reine Mengenvorlage.</td></tr>'}</tbody></table></div>
${frei ? `<div class="knopfreihe">${ANSATZ_ARTEN.map(([x, t]) => `<button class="neben klein" data-a="v-ansatz-neu" data-art="${x}">+ ${t}</button>`).join("")}</div>` : ""}
<p class="hinweis-k">Menge = Bezug × Ansatz × Personen; ohne Bezug je Einheit der Position. Beim Einfügen wird jede Zeile eine Kostenzeile der Position. Ein leerer EK beim Lohn nimmt den Stundensatz des Angebots.</p>`;
}
export async function vorlageSeite(id: string): Promise<void> {
const liste = await alleVorlagen(true);
let v = structuredClone(liste.find((x) => String(x.id) === id));
if (!v) { inhalt.innerHTML = '<p class="fehler">Diese Vorlage gibt es nicht (mehr).</p><p><a href="#stammdaten-mengen">Zu den Mengenvorlagen</a></p>'; return; }
v.inhalt = { ...alsBlatt(v.inhalt), ansaetze: v.inhalt.ansaetze ?? [] };
let meldung = "";
const wurzel = document.createElement("div");
inhalt.replaceChildren(wurzel);
const frei = !v.fest && !istHandy();
const zeichne = () => {
const fokus = document.activeElement as HTMLInputElement | null;
const k = fokus?.dataset?.k;
const a = werteBlatt(v!.inhalt, umgebungVon({}));
const gruppen = [...new Set(liste.map((x) => x.gruppe))];
wurzel.innerHTML = `${kuerzelListe("am-kuerzel", v!.inhalt)}<datalist id="am-gruppen">${gruppen.map((g) => `<option value="${esc(g)}">`).join("")}</datalist>
<datalist id="einheiten">${["m", "m²", "m³", "St", "kg", "t", "h", "psch"].map((x) => `<option value="${x}">`).join("")}</datalist>
<div class="kopf am-kopf"><a class="neben zurueck" href="#stammdaten-mengen" aria-label="Zu den Mengenvorlagen">←</a><h1>${v!.fest ? "Mitgelieferte Vorlage" : "Eigene Vorlage"} <span class="nummer">${esc(v!.name)}</span></h1>
<span class="kopf-knoepfe"><button class="neben" data-a="v-kopie">${v!.fest ? "Kopieren und ändern" : "Kopieren"}</button>${frei ? '<button class="neben gefahr" data-a="v-weg">Löschen</button>' : ""}</span></div>
${meldung ? `<div class="${meldung.startsWith("! ") ? "warnung" : "erfolg"}" role="status">${esc(meldung.replace(/^! /, ""))}</div>` : ""}
${v!.fest ? '<p class="hinweis">Diese Vorlage ist mitgeliefert und lässt sich nicht ändern. Mit „Kopieren und ändern“ wird sie deine eigene.</p>' : ""}
<div class="angebot-raster am-raster"><div class="am-haupt">
<section class="karte">${blattHtml(v!.inhalt, a, { k: "vb:", frei, modus: "vorlage", einheit: v!.einheit })}</section>
<section class="karte"><h3 class="am-h">4 Zeitansätze und Material <span class="hinweis-k">werden beim Einfügen zu Kostenzeilen der Position</span></h3>${ansaetzeHtml(v!, a, frei)}</section>
</div>
<aside class="angebot-seite">
<section class="karte am-speichern"><h3>Speichern als</h3>
<label class="am-radio"><input type="radio" name="v-art" data-k="v:art" data-typ="roh" value="mengen"${v!.art === "mengen" ? " checked" : ""}${frei ? "" : " disabled"}> nur Mengenvorlage</label>
<label class="am-radio"><input type="radio" name="v-art" data-k="v:art" data-typ="roh" value="muster"${v!.art === "muster" ? " checked" : ""}${frei ? "" : " disabled"}> Leistung mit Texten und Kalkulation</label>
<label>Name${feld("v:name", v!.name, { titel: "Name", frei })}</label>
<label>Gruppe${feld("v:gruppe", v!.gruppe, { titel: "Gruppe", frei, liste: "am-gruppen", platz: "z. B. Klempner / Blech" })}</label>
<label>Kurze Beschreibung${feld("v:beschreibung", v!.beschreibung, { titel: "Beschreibung", frei, platz: "steht unter dem Namen im Katalog" })}</label>
<label>Einheit der Position${feld("v:einheit", v!.einheit, { klasse: "w-kurz", titel: "Einheit", frei, liste: "einheiten" })}</label>
${v!.art === "muster" ? `<label>Kurztext${feld("v:kurztext", v!.kurztext, { titel: "Kurztext", frei })}</label>
<label>Langtext<textarea data-k="v:langtext" data-typ="roh" rows="5"${frei ? "" : " disabled"}>${esc(v!.langtext ?? "")}</textarea></label>
<p class="hinweis-k">{Z} oder {K} im Text setzt das Programm im Angebot mit den Werten des Mengenblatts ein.</p>` : ""}</section>
<section class="karte"><h3>So entsteht eine Vorlage</h3><ul class="am-liste-punkte">
<li>Im Angebot ein Mengenblatt bauen und „Als Vorlage speichern“, oder</li><li>Daten → Vorlagen → „Neue Vorlage“, oder</li><li>eine vorhandene Vorlage kopieren und ändern.</li></ul>
<p class="hinweis-k">Danach steht sie im Angebot rechts unter „Leistungen“ oder „Mengen“, für jedes neue Angebot.</p></section>
</aside></div>`;
if (k) wurzel.querySelector<HTMLInputElement>(`[data-k="${CSS.escape(k)}"]`)?.focus();
};
const speichern = async () => {
if (!frei) return;
const { id: _i, fest: _f, ...rest } = v as Mengenvorlage & Zeile;
const daten: Zeile = { art: rest.art, gruppe: rest.gruppe, name: rest.name, beschreibung: rest.beschreibung || null, kurztext: rest.kurztext || null,
langtext: rest.langtext || null, einheit: rest.einheit || null, inhalt: rest.inhalt };
await api(`mengenvorlagen/${id}`, "PATCH", daten);
vorlagenSpeicher = null;
};
const fehler = (e: unknown) => { meldung = `! ${(e as Error).message}`; zeichne(); };
zeichne();
wurzel.addEventListener("change", async (ev) => {
const el = ev.target as HTMLInputElement;
const k = el.dataset?.k;
if (!k) return;
meldung = "";
try {
if (k.startsWith("v:")) {
const f = k.slice(2);
if ((f === "name" || f === "gruppe") && !el.value.trim()) throw new Error("Name und Gruppe dürfen nicht leer sein.");
(v as Zeile)[f] = el.value.trim();
} else if (k.startsWith("vb:ansaetze.")) {
const [, i, f] = k.slice(3).split(".") as [string, string, string];
const z = v!.inhalt.ansaetze[Number(i)] as Ansatz & Record<string, unknown>;
if (el.dataset.typ === "bool") z[f] = el.checked;
else if (["menge", "personen", "faktor"].includes(f)) z[f] = el.value.trim() ? zahlAus(el.value) : f === "menge" ? 0 : 1;
else if (f === "ek") z.ek = el.value.trim() ? parseEuro(el.value) : null;
else z[f] = el.value.trim() || null;
if (f === "kostenart") { z.lohnart = z.kostenart === "lohn" ? "geselle" : null; z.einheit = z.kostenart === "lohn" ? "h" : null; }
} else if (k.startsWith("vb:")) setze(v!.inhalt, k.slice(3), el.value);
await speichern();
zeichne();
} catch (e) { fehler(e); }
});
wurzel.addEventListener("click", async (ev) => {
const b = (ev.target as HTMLElement).closest<HTMLElement>("[data-a]");
if (!b) return;
const a = b.dataset.a!;
try {
if (a.startsWith("b-")) { if (blattAktion(v!.inhalt, a, b.dataset)) { await speichern(); zeichne(); } return; }
if (a === "v-ansatz-neu") {
const art = b.dataset.art as Ansatz["kostenart"];
v!.inhalt.ansaetze.push({ kostenart: art, lohnart: art === "lohn" ? "geselle" : null, beschreibung: "", bezug: v!.inhalt.menge || "", menge: art === "lohn" ? 0.1 : 1, personen: 1, einheit: art === "lohn" ? "h" : v!.einheit ?? null });
await speichern(); return zeichne();
}
if (a === "v-ansatz-weg") { v!.inhalt.ansaetze.splice(Number(b.dataset.i), 1); await speichern(); return zeichne(); }
if (a === "v-kopie") {
const { id: _i, fest: _f, reihenfolge: _r, ...rest } = v as Mengenvorlage & Zeile;
const neu = await api<Zeile>("mengenvorlagen", "POST", { ...rest, name: v!.fest ? rest.name : `${rest.name} (Kopie)`, beschreibung: rest.beschreibung || null,
kurztext: rest.kurztext || null, langtext: rest.langtext || null, einheit: rest.einheit || null });
vorlagenSpeicher = null;
hinweis.gut = true;
hinweis.text = "Kopie angelegt. Sie gehört jetzt dir und lässt sich ändern.";
location.hash = `vorlage-${neu.id}`;
return;
}
if (a === "v-weg") {
if (!(await bestaetigen(`Vorlage „${v!.name}“ löschen? Angebote, in die sie schon eingefügt ist, behalten ihr Mengenblatt.`))) return;
await api(`mengenvorlagen/${id}`, "DELETE");
vorlagenSpeicher = null;
location.hash = "stammdaten-mengen";
}
} catch (e) { fehler(e); }
});
if (hinweis.text) { meldung = hinweis.text; hinweis.text = ""; hinweis.gut = false; zeichne(); }
}