Files
Betriebsf-hrungssoftware/src/domain/mengenblatt.ts
Claude 0bbb756b98
Some checks failed
Prüfung / tests (push) Has been cancelled
Prüfung / container (push) Has been cancelled
Neue Angebotsmaske: Mengenblatt mit Formeln, Musterpositionen und Mengenvorlagen im Katalog, Kostenzeilen mit Bezug, Subunternehmer (0.17.0)
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01AmyPfuNc4sCRfaF3oURXZz
2026-10-21 08:23:55 +00:00

198 lines
8.4 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 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");
}