Neue Angebotsmaske: Mengenblatt mit Formeln, Musterpositionen und Mengenvorlagen im Katalog, Kostenzeilen mit Bezug, Subunternehmer (0.17.0)
Some checks failed
Prüfung / tests (push) Has been cancelled
Prüfung / container (push) Has been cancelled

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-21 08:23:55 +00:00
parent 3694105216
commit 0bbb756b98
17 changed files with 2456 additions and 231 deletions

451
src/web/mengenblatt.ts Normal file
View File

@@ -0,0 +1,451 @@
// 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, LOHNARTEN, LOHNART_NAME, umgebungVon } from "../domain/kalkulation.js";
import { type Zeile, api, bestaetigen, dialog, esc, hinweis, inhalt, 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 (Listen nur lesen); 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]!;
const lesen = o.modus === "inline";
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="#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(LOHNARTEN.map((x) => [x, LOHNART_NAME[x]]), 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="#vorlagen">Zu den Vorlagen</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;
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="#vorlagen" aria-label="Zu den Vorlagen">←</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"}> Musterposition 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 Bausteine (Musterpositionen) und Mengenvorlagen, 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 = "vorlagen";
}
} catch (e) { fehler(e); }
});
if (hinweis.text) { meldung = hinweis.text; hinweis.text = ""; hinweis.gut = false; zeichne(); }
}
/** Daten → Vorlagen: alle Mengenvorlagen und Musterpositionen */
export async function vorlagenSeite(): Promise<void> {
const liste = await alleVorlagen(true);
let suche = "";
const wurzel = document.createElement("div");
inhalt.replaceChildren(wurzel);
const zeichne = () => {
const s = suche.trim().toLowerCase();
const passend = liste.filter((v) => !s || `${v.name} ${v.gruppe} ${v.beschreibung ?? ""}`.toLowerCase().includes(s));
const gruppen = [...new Set(passend.map((v) => v.gruppe))];
wurzel.innerHTML = `<div class="kopf"><a class="neben zurueck" href="#daten" aria-label="Zu den Daten">←</a><h1>Vorlagen</h1><button class="haupt" data-a="neu">Neue Vorlage</button></div>
<p class="hinweis">Mengenvorlagen rechnen die Menge einer Position aus Eingaben und Formeln. Musterpositionen bringen dazu Kurztext, Langtext und Zeitansätze mit. Beides fügst du im Angebot rechts unter „Bausteine“ und „Mengenvorlagen“ ein.</p>
<input class="am-suche-seite" type="search" placeholder="Vorlage suchen …" value="${esc(suche)}" aria-label="Vorlage suchen">
${gruppen.map((g) => `<h2 class="am-gruppe">${esc(g)}</h2><ul class="dokumente">${passend.filter((v) => v.gruppe === g).map((v) => `<li><a class="dokument" href="#vorlage-${esc(v.id)}"><span><b>${esc(v.name)}</b>
<span class="unter">${v.art === "muster" ? "Musterposition" : "Mengenvorlage"}${v.einheit ? `, Menge in ${esc(v.einheit)}` : ""}${v.beschreibung ? ` · ${esc(v.beschreibung)}` : ""}</span></span>
<span class="marken"><span class="marke ${v.fest ? "grau" : "gut"}">${v.fest ? "mitgeliefert" : "eigene"}</span></span></a></li>`).join("")}</ul>`).join("") || '<p class="hinweis leer">Nichts gefunden.</p>'}`;
};
zeichne();
wurzel.addEventListener("input", (ev) => {
const el = ev.target as HTMLInputElement;
if (!el.classList.contains("am-suche-seite")) return;
suche = el.value;
const pos = el.selectionStart;
zeichne();
const neu = wurzel.querySelector<HTMLInputElement>(".am-suche-seite")!;
neu.focus();
neu.setSelectionRange(pos, pos);
});
wurzel.addEventListener("click", async (ev) => {
if ((ev.target as HTMLElement).closest("[data-a]")?.getAttribute("data-a") !== "neu") return;
const r = await dialog("Neue Vorlage", [
{ name: "name", titel: "Name", pflicht: true }, { name: "gruppe", titel: "Gruppe", pflicht: true, hilfe: "z. B. Dach, Wand, Klempner / Blech" },
{ name: "art", titel: "Art", art: "auswahl", optionen: [["mengen", "Mengenvorlage"], ["muster", "Musterposition mit Texten und Kalkulation"]] },
{ name: "einheit", titel: "Einheit der Position", hilfe: "m, m², m³, St, psch" },
], { art: "mengen", einheit: "m" }, false);
if (r?.aktion !== "speichern") return;
const neu = await api<Zeile>("mengenvorlagen", "POST", { name: r.daten.name, gruppe: r.daten.gruppe, art: r.daten.art ?? "mengen", einheit: r.daten.einheit || null,
inhalt: { werte: [{ kz: "L", bez: "Länge", einheit: "m", formel: "1", eingabe: true }], listen: [], zeilen: [], menge: "L", ansaetze: [] } });
vorlagenSpeicher = null;
location.hash = `vorlage-${neu.id}`;
});
}