Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01AmyPfuNc4sCRfaF3oURXZz
198 lines
8.4 KiB
TypeScript
198 lines
8.4 KiB
TypeScript
// 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");
|
||
}
|