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

197
src/domain/mengenblatt.ts Normal file
View File

@@ -0,0 +1,197 @@
// Mengenblatt je Position (A22): Eingaben und Formeln mit Kürzeln, Listen wie die Wandliste W/F/G und freie
// Aufmaßzeilen wie in Plancraft (Beschreibung, Formel, Ergebnis). Eine Formel oder die Summe der Aufmaßzeilen ist
// die Menge der Position; Kostenzeilen beziehen sich mit Kürzeln darauf (z. B. Abbund = HL × 0,03 Std × 2 Personen).
import { type Kontext, type Wert, FormelFehler, berechne, zahlDeutsch } from "./formel.js";
export interface BlattWert {
kz: string;
bez?: string | null;
einheit?: string | null;
/** Wert oder Formel als Text, so wie eingetippt */
formel: string;
/** gelb: wird beim Einfügen abgefragt und auf der Baustelle gemessen */
eingabe?: boolean;
}
export interface BlattSpalte {
kz: string;
bez?: string | null;
einheit?: string | null;
/** Text (z. B. Kennung W/F/G) oder Zahl */
art?: "text" | "zahl";
/** berechnete Spalte: Formel mit den Kürzeln der Spalten dieser Zeile */
formel?: string | null;
}
export interface BlattListe {
kz: string;
name?: string | null;
spalten: BlattSpalte[];
zeilen: Record<string, string>[];
}
export interface AufmassZeile {
text?: string | null;
formel: string;
}
export interface Blatt {
vorlage?: { id: string; name: string } | null;
werte: BlattWert[];
listen: BlattListe[];
zeilen: AufmassZeile[];
/** Kürzel oder Formel für die Menge; leer = Summe der Aufmaßzeilen */
menge?: string | null;
}
export const leeresBlatt = (): Blatt => ({ werte: [], listen: [], zeilen: [] });
export function alsBlatt(x: unknown): Blatt {
const b = (x && typeof x === "object" ? x : {}) as Partial<Blatt>;
return {
vorlage: b.vorlage ?? null, menge: b.menge ?? null,
werte: Array.isArray(b.werte) ? b.werte : [], listen: Array.isArray(b.listen) ? b.listen : [], zeilen: Array.isArray(b.zeilen) ? b.zeilen : [],
};
}
export interface Auswertung {
/** Ergebnis je Kürzel (nur fehlerfreie) */
werte: Record<string, number>;
/** Ergebnis je Eintrag: w:i, z:i, l:i:zeile:spalte; null bei Fehler */
ergebnis: Record<string, Wert | null>;
/** Fehler je Eintrag (gleiche Schlüssel, dazu „menge“) */
fehler: Record<string, string>;
summeZeilen: number;
/** Menge der Position aus dem Blatt, null wenn nichts eingetragen oder fehlerhaft */
menge: number | null;
/** eine weitere Formel mit den Kürzeln des Blatts rechnen (Bezug einer Kostenzeile) */
rechne(formel: string): number;
}
/**
* Das Blatt ausrechnen. Werte werden erst bei Bedarf und je einmal gerechnet; ein Kreisbezug ist ein Fehler.
* `umgebung` liefert feste Größen wie VERSCHNITT oder ÖFFNUNG_AB aus den Vorgaben des Angebots.
*/
export function werteBlatt(blatt: Blatt, umgebung: Record<string, number> = {}): Auswertung {
const b = alsBlatt(blatt);
const ergebnis: Record<string, Wert | null> = {};
const fehler: Record<string, string> = {};
const werte: Record<string, number> = {};
const wertIndex = new Map<string, number>();
b.werte.forEach((w, i) => {
const kz = (w.kz ?? "").trim();
if (!kz) return;
if (wertIndex.has(kz)) fehler[`w:${i}`] = `Kürzel „${kz}“ gibt es zweimal`;
else wertIndex.set(kz, i);
});
const listen = new Map(b.listen.map((l, i) => [l.kz, i] as const));
const fertig = new Map<string, Wert>();
const kaputt = new Map<string, string>();
const inArbeit = new Set<string>();
const merke = (schluessel: string, rechnen: () => Wert): Wert => {
if (fertig.has(schluessel)) return fertig.get(schluessel)!;
if (kaputt.has(schluessel)) throw new FormelFehler(kaputt.get(schluessel)!);
if (inArbeit.has(schluessel)) throw new FormelFehler("Kreisbezug: die Formel braucht ihr eigenes Ergebnis");
inArbeit.add(schluessel);
try {
const v = rechnen();
if (typeof v === "number" && !Number.isFinite(v)) throw new FormelFehler("Ergebnis ist keine Zahl");
fertig.set(schluessel, v);
return v;
} catch (e) {
const m = e instanceof FormelFehler ? e.message : String(e);
kaputt.set(schluessel, m);
throw new FormelFehler(m);
} finally {
inArbeit.delete(schluessel);
}
};
const leer = (f: string | null | undefined) => !f || !f.trim();
const wertVon = (i: number): Wert => merke(`w:${i}`, () => {
const w = b.werte[i]!;
return leer(w.formel) ? 0 : berechne(w.formel, global);
});
const zelle = (li: number, zi: number, spalte: string): Wert => merke(`l:${li}:${zi}:${spalte}`, () => {
const l = b.listen[li]!;
const s = l.spalten.find((x) => x.kz === spalte);
if (!s) throw new FormelFehler(`Spalte „${spalte}“ gibt es in ${l.name || l.kz} nicht`);
const roh = s.formel?.trim() ? s.formel : l.zeilen[zi]?.[spalte] ?? "";
if (s.art === "text" && !s.formel?.trim()) return String(roh).trim();
if (leer(roh)) return 0;
return berechne(roh, zeilenKontext(li, zi));
});
const kennt = (name: string): Wert => {
const i = wertIndex.get(name);
if (i !== undefined) {
try { return wertVon(i); } catch (e) {
throw new FormelFehler((e as Error).message.startsWith("Kreisbezug") ? (e as Error).message : `„${name}“ hat selbst einen Fehler`);
}
}
if (name in umgebung) return umgebung[name]!;
throw new FormelFehler(`„${name}“ unbekannt`);
};
const spalteVon = (liste: string, spalte: string): Wert[] => {
const li = listen.get(liste);
if (li === undefined) throw new FormelFehler(`Liste „${liste}“ unbekannt`);
const l = b.listen[li]!;
if (!l.spalten.some((s) => s.kz === spalte)) throw new FormelFehler(`Spalte „${spalte}“ gibt es in ${l.name || liste} nicht`);
return l.zeilen.map((_, zi) => {
try { return zelle(li, zi, spalte); } catch { throw new FormelFehler(`${l.name || liste}, Zeile ${zi + 1}, ${spalte} hat einen Fehler`); }
});
};
const zeilenZahl = (liste: string) => { const li = listen.get(liste); return li === undefined ? -1 : b.listen[li]!.zeilen.length; };
const global: Kontext = { wert: kennt, spalte: spalteVon, zeilen: zeilenZahl };
const zeilenKontext = (li: number, zi: number): Kontext => ({
...global,
wert: (name) => (b.listen[li]!.spalten.some((s) => s.kz === name) ? zelle(li, zi, name) : kennt(name)),
});
const zahl = (v: Wert) => (typeof v === "number" ? v : Number.NaN);
const versuche = (schluessel: string, f: () => Wert) => {
try { ergebnis[schluessel] = f(); } catch (e) { ergebnis[schluessel] = null; fehler[schluessel] ??= (e as Error).message; }
};
b.werte.forEach((w, i) => {
versuche(`w:${i}`, () => wertVon(i));
const v = ergebnis[`w:${i}`];
if (typeof v === "number" && w.kz && !fehler[`w:${i}`]) werte[w.kz.trim()] = v;
});
b.listen.forEach((l, li) => l.zeilen.forEach((_, zi) => l.spalten.forEach((s) => versuche(`l:${li}:${zi}:${s.kz}`, () => zelle(li, zi, s.kz)))));
let summeZeilen = 0;
b.zeilen.forEach((z, i) => {
if (leer(z.formel)) { ergebnis[`z:${i}`] = null; return; }
versuche(`z:${i}`, () => berechne(z.formel, global));
const v = ergebnis[`z:${i}`];
if (typeof v === "number") summeZeilen += v;
});
let menge: number | null = null;
if (!leer(b.menge)) {
try { menge = zahl(berechne(b.menge!, global)); if (!Number.isFinite(menge)) throw new FormelFehler("Menge ist keine Zahl"); }
catch (e) { menge = null; fehler.menge = (e as Error).message; }
} else if (b.zeilen.some((z) => !leer(z.formel))) menge = summeZeilen;
if (menge !== null) menge = Math.round(menge * 10000) / 10000;
return {
werte, ergebnis, fehler, summeZeilen: Math.round(summeZeilen * 10000) / 10000, menge,
rechne: (f) => {
const v = berechne(f, global);
if (typeof v !== "number" || !Number.isFinite(v)) throw new FormelFehler("Ergebnis ist keine Zahl");
return v;
},
};
}
/** {Z} und {K} im Kurz- oder Langtext durch die Werte des Mengenblatts ersetzen (Bild 6 vom 21.10.2026) */
export function textMitWerten(text: string, a: Pick<Auswertung, "werte"> | null, einheiten: Record<string, string | null | undefined> = {}): string {
if (!text.includes("{")) return text;
return text.replace(/\{([\p{L}_][\p{L}\p{N}_]*)\}/gu, (ganz, kz: string) => (a && kz in a.werte ? zahlDeutsch(a.werte[kz]!, einheiten[kz]) : ganz));
}
/** Platzhalter {KZ}, die im Mengenblatt fehlen */
export function fehlendePlatzhalter(text: string | null | undefined, a: Pick<Auswertung, "werte"> | null): string[] {
if (!text) return [];
return [...text.matchAll(/\{([\p{L}_][\p{L}\p{N}_]*)\}/gu)].map((m) => m[1]!).filter((kz) => !a || !(kz in a.werte) && kz !== "bindefrist");
}