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

302
src/domain/formel.ts Normal file
View File

@@ -0,0 +1,302 @@
// Formeln für Aufmaß und Mengenblatt (Stufe 3a, A22, Henning 21.10.2026): rechnen mit Kürzeln statt Zellbezügen,
// z. B. (B/2+UET)/cos(DN). Komma oder Punkt als Dezimalzeichen, Semikolon trennt Argumente: runden(x; 2).
// Winkel in Grad wie auf der Baustelle. Ein unbekanntes Kürzel ist ein Fehler, keine stille Null.
export type Wert = number | string;
export class FormelFehler extends Error {}
type Knoten =
| { t: "n"; v: number }
| { t: "s"; v: string }
| { t: "id"; name: string }
| { t: "f"; name: string; args: Knoten[] }
| { t: "op"; op: string; a: Knoten; b: Knoten }
| { t: "neg"; a: Knoten }
| { t: "pct"; a: Knoten };
type Token = { t: "n"; v: number } | { t: "s"; v: string } | { t: "id"; v: string } | { t: "o"; v: string };
const BUCHSTABE = /[\p{L}_]/u;
const ZEICHEN = /[\p{L}\p{N}_]/u;
function zerlege(f: string): Token[] {
const t: Token[] = [];
let i = 0;
while (i < f.length) {
const c = f[i]!;
if (/\s/.test(c)) { i++; continue; }
if (/\d/.test(c) || (c === "," || c === ".") && /\d/.test(f[i + 1] ?? "")) {
const m = /^\d*(?:[.,]\d+)?/.exec(f.slice(i))!;
t.push({ t: "n", v: Number(m[0].replace(",", ".")) });
i += m[0].length;
// „2,5 m“ oder „31°“: Einheit hinter einer Zahl überlesen
const e = /^\s*(?:°|m³|m²|m(?![\p{L}\p{N}_(]))/u.exec(f.slice(i));
if (e) i += e[0].length;
continue;
}
if (c === '"' || c === "„" || c === "“" || c === "'") {
const ende = f.slice(i + 1).search(/["“”']/);
if (ende < 0) throw new FormelFehler("Anführungszeichen nicht geschlossen");
t.push({ t: "s", v: f.slice(i + 1, i + 1 + ende) });
i += ende + 2;
continue;
}
if (BUCHSTABE.test(c)) {
let j = i + 1;
while (j < f.length && (ZEICHEN.test(f[j]!) || (f[j] === "." && BUCHSTABE.test(f[j + 1] ?? "")))) j++;
t.push({ t: "id", v: f.slice(i, j) });
i = j;
continue;
}
const zwei = f.slice(i, i + 2);
if (["<>", "!=", "<=", ">="].includes(zwei)) { t.push({ t: "o", v: zwei === "!=" ? "<>" : zwei }); i += 2; continue; }
const eins: Record<string, string> = { "×": "*", "·": "*", "≠": "<>", "≤": "<=", "≥": ">=", "−": "-", ",": ";" };
if ("+-*/^();%=<>".includes(c) || c in eins) { t.push({ t: "o", v: eins[c] ?? c }); i++; continue; }
throw new FormelFehler(`Zeichen „${c}“ ist nicht erlaubt`);
}
return t;
}
function parse(f: string): Knoten {
const t = zerlege(f);
let i = 0;
const ist = (v: string) => t[i]?.t === "o" && t[i]!.v === v;
const erwarte = (v: string) => {
if (!ist(v)) throw new FormelFehler(v === ")" ? "Klammer zu fehlt" : `„${v}“ fehlt`);
i++;
};
const ausdruck = (): Knoten => {
const a = summe();
for (const op of ["=", "<>", "<=", ">=", "<", ">"]) if (ist(op)) { i++; return { t: "op", op, a, b: summe() }; }
return a;
};
const summe = (): Knoten => {
let a = produkt();
while (ist("+") || ist("-")) { const op = (t[i++] as { v: string }).v; a = { t: "op", op, a, b: produkt() }; }
return a;
};
const produkt = (): Knoten => {
let a = vorzeichen();
while (ist("*") || ist("/")) { const op = (t[i++] as { v: string }).v; a = { t: "op", op, a, b: vorzeichen() }; }
return a;
};
const vorzeichen = (): Knoten => {
if (ist("-")) { i++; return { t: "neg", a: vorzeichen() }; }
if (ist("+")) { i++; return vorzeichen(); }
return potenz();
};
const potenz = (): Knoten => {
const a = prozent();
if (ist("^")) { i++; return { t: "op", op: "^", a, b: vorzeichen() }; }
return a;
};
const prozent = (): Knoten => {
let a = einfach();
while (ist("%")) { i++; a = { t: "pct", a }; }
return a;
};
const einfach = (): Knoten => {
const x = t[i];
if (!x) throw new FormelFehler(t.length ? "Formel unvollständig" : "leer");
i++;
if (x.t === "n") return { t: "n", v: x.v };
if (x.t === "s") return { t: "s", v: x.v };
if (x.t === "id") {
if (!ist("(")) return { t: "id", name: x.v };
i++;
const args: Knoten[] = [];
if (!ist(")")) {
args.push(ausdruck());
while (ist(";")) { i++; args.push(ausdruck()); }
}
erwarte(")");
return { t: "f", name: x.v.toLowerCase(), args };
}
if (x.v === "(") { const a = ausdruck(); erwarte(")"); return a; }
throw new FormelFehler(`„${x.v}“ an dieser Stelle geht nicht`);
};
const a = ausdruck();
if (i < t.length) {
const x = t[i]!;
throw new FormelFehler(x.t === "o" && x.v === ")" ? "Klammer auf fehlt" : `Nach „${f.slice(0, 20)}“ fehlt ein Rechenzeichen`);
}
return a;
}
const SPEICHER = new Map<string, Knoten | FormelFehler>();
function uebersetzt(f: string): Knoten {
let k = SPEICHER.get(f);
if (!k) {
try { k = parse(f); } catch (e) { k = e instanceof FormelFehler ? e : new FormelFehler(String(e)); }
if (SPEICHER.size > 5000) SPEICHER.clear();
SPEICHER.set(f, k);
}
if (k instanceof FormelFehler) throw k;
return k;
}
export interface Kontext {
/** Wert eines Kürzels; unbekannt → FormelFehler */
wert(name: string): Wert;
/** Spalte einer Liste („Wand.Breite“) für summe(), summewenn() und anzahl() */
spalte?(liste: string, spalte: string): Wert[];
/** Zeilenzahl einer Liste */
zeilen?(liste: string): number;
}
const GRAD = Math.PI / 180;
const zahl = (w: Wert, wo = "Wert"): number => {
if (typeof w === "number") return w;
const n = Number(w.trim().replace(",", "."));
if (w.trim() === "" ) return 0;
if (!Number.isFinite(n)) throw new FormelFehler(`${wo} „${w}“ ist keine Zahl`);
return n;
};
const gleich = (a: Wert, b: Wert) =>
typeof a === "string" || typeof b === "string" ? String(a).trim().toLowerCase() === String(b).trim().toLowerCase() : Math.abs(a - b) < 1e-9;
const stellen = (args: number[]) => 10 ** Math.round(args[1] ?? 0);
// gleiche Namen wie in Excel gehen auch, damit Formeln aus den Musterpositionen passen
const NAMEN: Record<string, string> = {
roundup: "aufrunden", obergrenze: "aufrunden", rounddown: "abrunden", untergrenze: "abrunden", round: "runden", sqrt: "wurzel",
if: "wenn", and: "und", or: "oder", not: "nicht", choose: "wahl", sum: "summe", count: "anzahl", sumif: "summewenn", countif: "anzahlwenn",
atan: "arctan", asin: "arcsin", acos: "arccos", mod: "rest", int: "ganzzahl",
};
export const FUNKTIONEN = ["aufrunden", "abrunden", "runden", "min", "max", "abs", "wurzel", "sin", "cos", "tan", "arcsin", "arccos", "arctan", "pi",
"wenn", "und", "oder", "nicht", "wahl", "summe", "anzahl", "summewenn", "anzahlwenn", "rest", "ganzzahl"];
function rechne(k: Knoten, x: Kontext): Wert {
switch (k.t) {
case "n": case "s": return k.v;
case "id":
if (k.name.includes(".")) throw new FormelFehler(`„${k.name}“ ist eine Listenspalte; nutze summe(${k.name})`);
return x.wert(k.name);
case "neg": return -zahl(rechne(k.a, x));
case "pct": return zahl(rechne(k.a, x)) / 100;
case "op": {
const a = rechne(k.a, x), b = rechne(k.b, x);
switch (k.op) {
case "=": return gleich(a, b) ? 1 : 0;
case "<>": return gleich(a, b) ? 0 : 1;
case "<": return zahl(a) < zahl(b) - 1e-12 ? 1 : 0;
case ">": return zahl(a) > zahl(b) + 1e-12 ? 1 : 0;
case "<=": return zahl(a) <= zahl(b) + 1e-12 ? 1 : 0;
case ">=": return zahl(a) >= zahl(b) - 1e-12 ? 1 : 0;
case "+": return zahl(a) + zahl(b);
case "-": return zahl(a) - zahl(b);
case "*": return zahl(a) * zahl(b);
case "/": { const n = zahl(b); if (n === 0) throw new FormelFehler("Teilen durch 0"); return zahl(a) / n; }
case "^": return zahl(a) ** zahl(b);
}
throw new FormelFehler(`Rechenzeichen ${k.op}`);
}
case "f": return funktion(NAMEN[k.name] ?? k.name, k.args, x);
}
}
/** Werte einer Listenspalte, oder einzelne Zahlen, für summe() und Co. */
function sammle(args: Knoten[], x: Kontext): Wert[] {
const aus: Wert[] = [];
for (const a of args) {
if (a.t === "id" && a.name.includes(".")) {
const [l, s] = a.name.split(".") as [string, string];
if (!x.spalte) throw new FormelFehler(`Liste „${l}“ gibt es hier nicht`);
aus.push(...x.spalte(l, s));
} else aus.push(rechne(a, x));
}
return aus;
}
function funktion(name: string, args: Knoten[], x: Kontext): Wert {
const n = () => args.map((a) => zahl(rechne(a, x)));
const genau = (anzahl: number, bis = anzahl) => {
if (args.length < anzahl || args.length > bis) throw new FormelFehler(`${name}() braucht ${anzahl === bis ? anzahl : `${anzahl} bis ${bis}`} ${bis === 1 ? "Wert" : "Werte"}`);
};
switch (name) {
case "aufrunden": { genau(1, 2); const v = n(), f = stellen(v); return Math.ceil(v[0]! * f - 1e-9) / f; }
case "abrunden": { genau(1, 2); const v = n(), f = stellen(v); return Math.floor(v[0]! * f + 1e-9) / f; }
case "runden": { genau(1, 2); const v = n(), f = stellen(v); return Math.sign(v[0]!) * Math.round(Math.abs(v[0]!) * f + 1e-9) / f; }
case "ganzzahl": genau(1); return Math.trunc(n()[0]!);
case "rest": { genau(2); const [a, b] = n() as [number, number]; if (b === 0) throw new FormelFehler("Teilen durch 0"); return a - b * Math.floor(a / b); }
case "min": case "max": {
const v = sammle(args, x).map((w) => zahl(w));
if (!v.length) throw new FormelFehler(`${name}() braucht Werte`);
return name === "min" ? Math.min(...v) : Math.max(...v);
}
case "abs": genau(1); return Math.abs(n()[0]!);
case "wurzel": { genau(1); const v = n()[0]!; if (v < 0) throw new FormelFehler("Wurzel aus einer negativen Zahl"); return Math.sqrt(v); }
case "sin": genau(1); return Math.sin(n()[0]! * GRAD);
case "cos": genau(1); return Math.cos(n()[0]! * GRAD);
case "tan": genau(1); return Math.tan(n()[0]! * GRAD);
case "arcsin": genau(1); return Math.asin(n()[0]!) / GRAD;
case "arccos": genau(1); return Math.acos(n()[0]!) / GRAD;
case "arctan": genau(1); return Math.atan(n()[0]!) / GRAD;
case "pi": genau(0); return Math.PI;
case "wenn": genau(2, 3); return zahl(rechne(args[0]!, x)) !== 0 ? rechne(args[1]!, x) : args[2] ? rechne(args[2], x) : 0;
case "und": return args.every((a) => zahl(rechne(a, x)) !== 0) ? 1 : 0;
case "oder": return args.some((a) => zahl(rechne(a, x)) !== 0) ? 1 : 0;
case "nicht": genau(1); return zahl(rechne(args[0]!, x)) === 0 ? 1 : 0;
case "wahl": {
if (args.length < 2) throw new FormelFehler("wahl() braucht eine Nummer und Werte");
const i = Math.round(zahl(rechne(args[0]!, x)));
if (i < 1 || i >= args.length) throw new FormelFehler(`wahl(): ${i} gibt es nicht`);
return rechne(args[i]!, x);
}
case "summe": return sammle(args, x).reduce((s: number, w) => s + zahl(w), 0);
case "anzahl": {
if (args.length === 1 && args[0]!.t === "id" && !args[0]!.name.includes(".")) {
const l = args[0]!.name;
if (x.zeilen) { const z = x.zeilen(l); if (z >= 0) return z; }
}
return sammle(args, x).filter((w) => String(w).trim() !== "").length;
}
case "summewenn": case "anzahlwenn": {
const mitSumme = name === "summewenn";
genau(mitSumme ? 3 : 2);
const werte = mitSumme ? sammle([args[0]!], x) : [];
const kriterien = sammle([args[mitSumme ? 1 : 0]!], x);
const soll = rechne(args[mitSumme ? 2 : 1]!, x);
let s = 0;
kriterien.forEach((k, i) => { if (gleich(k, soll)) s += mitSumme ? zahl(werte[i] ?? 0) : 1; });
return s;
}
}
throw new FormelFehler(`Funktion „${name}“ gibt es nicht`);
}
/** Eine Formel ausrechnen; Fehler als FormelFehler */
export function berechne(formel: string, x: Kontext): Wert {
return rechne(uebersetzt(formel), x);
}
/** Nur prüfen, ob die Formel lesbar ist (ohne Kürzel aufzulösen) */
export function formelFehler(formel: string): string | null {
try { uebersetzt(formel); return null; } catch (e) { return (e as Error).message; }
}
/** Alle Kürzel, die eine Formel benutzt (ohne Funktionsnamen) */
export function kuerzelIn(formel: string): string[] {
try {
return zerlege(formel).filter((t, i, a) => t.t === "id" && !(a[i + 1]?.t === "o" && a[i + 1]!.v === "(")).map((t) => t.v as string);
} catch { return []; }
}
export const KUERZEL = /^[\p{L}_][\p{L}\p{N}_]*$/u;
/** Kürzel in einer Formel umbenennen (nicht in Texten in Anführungszeichen, nicht hinter einem Punkt) */
export function benenneUm(formel: string, alt: string, neu: string): string {
if (!alt || !neu || alt === neu) return formel;
const teile = formel.split(/(["„“'][^"“”']*["“”'])/);
return teile.map((t, i) => (i % 2 ? t : t.replace(new RegExp(`(?<![\\p{L}\\p{N}_.])${alt.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}(?![\\p{L}\\p{N}_(])`, "gu"), neu))).join("");
}
/** Zahl für Mengenblatt und Texte: ganze Zahlen ohne Komma, sonst bis 3 Stellen, mindestens 2 */
export function zahlDeutsch(n: number, einheit?: string | null): string {
if (!Number.isFinite(n)) return "–";
const ganz = Math.abs(n - Math.round(n)) < 1e-9;
const flaeche = einheit && /^(m|m²|m³|lfm|h)$/.test(einheit);
const r = Math.round(n * 1000) / 1000;
const min = ganz && !flaeche ? 0 : 2;
return r.toLocaleString("de-DE", { minimumFractionDigits: min, maximumFractionDigits: Math.max(min, 3) });
}

View File

@@ -4,11 +4,13 @@
// die zählen. So gibt es keine Rundungsabweichung wie in Plancraft: Zuschlag in € = Verkauf − Kosten.
import type { Cent } from "./geld.js";
import { prozentVon } from "./geld.js";
import { type Auswertung, type Blatt, alsBlatt, fehlendePlatzhalter, werteBlatt } from "./mengenblatt.js";
export const KOSTENARTEN = ["lohn", "material", "geraet", "sonstiges"] as const;
// Subunternehmer eigene Kostenart mit eigenem Zuschlag (Bild 2 vom 21.10.2026)
export const KOSTENARTEN = ["lohn", "material", "geraet", "subunternehmer", "sonstiges"] as const;
export type Kostenart = (typeof KOSTENARTEN)[number];
export const KOSTENART_NAME: Record<Kostenart | "ohne", string> = {
lohn: "Lohn", material: "Material", geraet: "Gerät", sonstiges: "Sonstiges", ohne: "ohne Kalkulation",
lohn: "Lohn", material: "Material", geraet: "Gerät", subunternehmer: "Subunternehmer", sonstiges: "Sonstiges", ohne: "ohne Kalkulation",
};
export const LOHNARTEN = ["planer", "geselle", "helfer"] as const;
export type Lohnart = (typeof LOHNARTEN)[number];
@@ -43,6 +45,13 @@ export interface Saetze {
wagnis: number;
gewinn: number;
ausfall: number;
/** Vorgaben für Mengenblätter: Verschnitt in %, Öffnungen werden ab dieser Fläche (m²) abgezogen (E28) */
mengen?: { verschnitt: number; oeffnung_ab: number };
}
/** feste Größen, die jedes Mengenblatt kennt */
export function umgebungVon(s: Pick<Saetze, "mengen">): Record<string, number> {
return { VERSCHNITT: (s.mengen?.verschnitt ?? 10) / 100, ÖFFNUNG_AB: s.mengen?.oeffnung_ab ?? 2.5 };
}
export interface KKosten {
@@ -58,6 +67,11 @@ export interface KKosten {
ek?: number | string | null;
faktor?: number | string | null;
zuschlag_prozent?: number | string | null;
/** Kürzel oder Formel aus dem Mengenblatt; leer = Menge der Position, „menge“ ist dann je Einheit */
bezug?: string | null;
personen?: number | string | null;
/** abgewählt („nicht notwendig“): bleibt sichtbar, zählt nicht */
aktiv?: boolean | null;
reihenfolge?: number;
}
@@ -71,6 +85,13 @@ export interface KPosition {
art?: Positionsart | null;
/** fester Einheitspreis in Cent (Position ohne Kalkulation oder „Preis anpassen“) */
ep_fest?: number | string | null;
/** aus: fester Preis (ep_fest); an: Preis aus den Kostenzeilen, ep_fest ist dann „Preis anpassen“ */
mit_kalkulation?: boolean | null;
/** an: die Menge kommt aus dem Mengenblatt */
mit_aufmass?: boolean | null;
aufmass?: Blatt | null;
/** reine Textzeile im Leistungsverzeichnis, ohne Menge und Preis */
textzeile?: boolean | null;
reihenfolge?: number;
}
@@ -83,6 +104,10 @@ export interface KTitel {
export interface PositionErgebnis {
id: string;
/** Menge, mit der gerechnet wird: aus dem Mengenblatt, wenn Aufmaß an ist */
menge: number;
/** Fehler im Mengenblatt (dann zählt die eingetragene Menge) */
aufmass_fehler: string | null;
/** Einheitspreis in Cent */
ep: Cent;
/** Gesamtbetrag in Cent (zählt nur bei normal und eventual_summe) */
@@ -90,13 +115,16 @@ export interface PositionErgebnis {
/** Einheitspreis aus der Kalkulation, auch wenn ein fester Preis gilt */
ep_kalkuliert: Cent;
kosten_je_einheit: Cent;
/** Kosten der ganzen Position (ungerundet je Einheit × Menge, dann auf Cent) */
kosten_gesamt: Cent;
/** Stunden je Einheit und gesamt */
std_je_einheit: number;
stunden: number;
zaehlt: boolean;
/** Verkauf je Kostenart (Cent je Einheit, ungerundet) für die Kalkulationsübersicht */
vk_je_einheit: Record<Kostenart, number>;
kostenzeilen: { id?: string; kosten: number; verkauf: number; ek: number; zuschlag: number }[];
/** je Kostenzeile, in der Reihenfolge der Zeilen: Kosten und Verkauf je Einheit, Menge für die ganze Position */
kostenzeilen: { id?: string; kosten: number; verkauf: number; ek: number; zuschlag: number; menge_gesamt: number; aktiv: boolean; fehler: string | null }[];
}
export interface KostenartSumme {
@@ -155,28 +183,52 @@ export function zuschlagVon(k: KKosten, s: Saetze): number {
return k.zuschlag_prozent === null || k.zuschlag_prozent === undefined || k.zuschlag_prozent === "" ? s.zuschlaege[k.kostenart] ?? 0 : Number(k.zuschlag_prozent);
}
const leereArten = () => Object.fromEntries(KOSTENARTEN.map((a) => [a, 0])) as Record<Kostenart, number>;
/** Mengenblatt einer Position ausrechnen (nur wenn Aufmaß an ist) */
export function aufmassVon(p: Pick<KPosition, "mit_aufmass" | "aufmass">, s: Pick<Saetze, "mengen">): Auswertung | null {
return p.mit_aufmass && p.aufmass ? werteBlatt(alsBlatt(p.aufmass), umgebungVon(s)) : null;
}
export function berechnePosition(p: KPosition, kosten: KKosten[], s: Saetze): PositionErgebnis {
const wg = 1 + (s.wagnis + s.gewinn + s.ausfall) / 100;
const vk = { lohn: 0, material: 0, geraet: 0, sonstiges: 0 } as Record<Kostenart, number>;
const vk = leereArten();
let kostenSumme = 0, std = 0;
const zeilen = [];
const blatt = aufmassVon(p, s);
const aufmassFehler = blatt ? (Object.values(blatt.fehler)[0] ?? (blatt.menge === null ? "keine Menge" : null)) : null;
const menge = p.textzeile ? 0 : blatt && blatt.menge !== null && !blatt.fehler.menge ? blatt.menge : zahl(p.menge);
const kalk = p.mit_kalkulation !== false && !p.textzeile;
for (const k of kosten) {
const ek = ekVon(k, s);
const z = zuschlagVon(k, s);
const kz = zahl(k.menge) * ek * zahl(k.faktor, 1);
const personen = zahl(k.personen, 1);
// Menge je Einheit der Position; mit Bezug: Bezug × Ansatz × Personen für die ganze Position
let jeEinheit = zahl(k.menge) * personen, gesamt = jeEinheit * menge, fehler: string | null = null;
if (k.bezug && k.bezug.trim()) {
try {
const umg = blatt ?? werteBlatt({ werte: [], listen: [], zeilen: [] }, umgebungVon(s));
const bezug = /^\s*menge\s*$/i.test(k.bezug) ? menge : umg.rechne(k.bezug.replace(/\bMENGE\b/g, String(menge)));
gesamt = bezug * zahl(k.menge) * personen;
jeEinheit = menge > 0 ? gesamt / menge : 0;
} catch (e) { fehler = (e as Error).message; gesamt = 0; jeEinheit = 0; }
}
const aktiv = k.aktiv !== false;
const kz = aktiv ? jeEinheit * ek * zahl(k.faktor, 1) : 0;
const v = kz * (1 + z / 100) * wg;
kostenSumme += kz;
vk[k.kostenart] += v;
if (k.kostenart === "lohn") std += zahl(k.menge);
zeilen.push({ id: k.id, kosten: kz, verkauf: v, ek, zuschlag: z });
if (kalk) {
kostenSumme += kz;
vk[k.kostenart] += v;
if (k.kostenart === "lohn" && aktiv) std += jeEinheit;
}
zeilen.push({ id: k.id, kosten: kz, verkauf: v, ek, zuschlag: z, menge_gesamt: Math.round(gesamt * 10000) / 10000, aktiv, fehler });
}
const epKalk = rundeCent(KOSTENARTEN.reduce((t, a) => t + vk[a], 0));
const ep = p.ep_fest !== null && p.ep_fest !== undefined && p.ep_fest !== "" ? Number(p.ep_fest) : epKalk;
const menge = zahl(p.menge);
const z = zaehlt(p.art);
const fest = p.ep_fest !== null && p.ep_fest !== undefined && p.ep_fest !== "" ? Number(p.ep_fest) : null;
const ep = p.textzeile ? 0 : kalk ? fest ?? epKalk : fest ?? 0;
return {
id: p.id, ep, ep_kalkuliert: epKalk, gb: rundeCent(menge * ep), kosten_je_einheit: rundeCent(kostenSumme),
std_je_einheit: std, stunden: Math.round(menge * std * 100) / 100, zaehlt: z, vk_je_einheit: vk, kostenzeilen: zeilen,
id: p.id, menge, aufmass_fehler: aufmassFehler, ep, ep_kalkuliert: epKalk, gb: rundeCent(menge * ep), kosten_je_einheit: rundeCent(kostenSumme), kosten_gesamt: rundeCent(kostenSumme * menge),
std_je_einheit: std, stunden: Math.round(menge * std * 100) / 100, zaehlt: !p.textzeile && zaehlt(p.art), vk_je_einheit: vk, kostenzeilen: zeilen,
};
}
@@ -190,7 +242,7 @@ export function berechneAngebot(
}
const erg: Record<string, PositionErgebnis> = {};
const titelSumme: Record<string, Cent> = Object.fromEntries(titel.map((t) => [t.id, 0]));
const arten = { lohn: [0, 0], material: [0, 0], geraet: [0, 0], sonstiges: [0, 0], ohne: [0, 0] } as Record<Kostenart | "ohne", [number, Cent]>;
const arten = Object.fromEntries([...KOSTENARTEN, "ohne"].map((a) => [a, [0, 0]])) as Record<Kostenart | "ohne", [number, Cent]>;
let netto = 0, stunden = 0;
for (const p of positionen) {
const r = berechnePosition(p, jePosition.get(p.id) ?? [], s);
@@ -200,9 +252,8 @@ export function berechneAngebot(
stunden += r.stunden;
if (p.titel_id && p.titel_id in titelSumme) titelSumme[p.titel_id]! += r.gb;
// Kosten und Verkauf je Kostenart: der Gesamtbetrag der Position wird nach den Verkaufswerten aufgeteilt
const menge = zahl(p.menge);
for (const k of jePosition.get(p.id) ?? []) {
arten[k.kostenart][0] += menge * zahl(k.menge) * ekVon(k, s) * zahl(k.faktor, 1);
if (p.mit_kalkulation !== false) {
(jePosition.get(p.id) ?? []).forEach((k, i) => (arten[k.kostenart][0] += r.menge * (r.kostenzeilen[i]?.kosten ?? 0)));
}
const gewichte = KOSTENARTEN.map((x) => r.vk_je_einheit[x]);
if (gewichte.some((g) => g > 0)) verteile(r.gb, gewichte).forEach((t, i) => (arten[KOSTENARTEN[i]!][1] += t));
@@ -254,18 +305,28 @@ export function pruefeAngebot(
if (!positionen.some((x) => x.titel_id === t.id)) p.push({ stufe: "hinweis", text: `Titel „${t.bezeichnung}“ hat keine Position.` });
}
const ids = new Set(positionen.map((x) => x.id));
const saetzeLeer = { stundensaetze: { planer: 0, geselle: 0, helfer: 0 }, zuschlaege: leereArten(), wagnis: 0, gewinn: 0, ausfall: 0 };
for (const x of positionen) {
const r = e.positionen[x.id];
if (x.textzeile) {
if (PLATZHALTER.some((re) => re.test(x.kurztext))) p.push({ stufe: "fehler", text: `Textzeile „${x.kurztext.slice(0, 30)}“: Platzhalter im Text.`, position_id: x.id });
continue;
}
if (r?.aufmass_fehler) p.push({ stufe: "fehler", text: `Position ${name(x)}: Im Aufmaß ist ein Fehler (${r.aufmass_fehler}).`, position_id: x.id });
const fehlend = [...fehlendePlatzhalter(x.kurztext, aufmassVon(x, { mengen: undefined })), ...fehlendePlatzhalter(langtexte[x.id], aufmassVon(x, { mengen: undefined }))];
if (fehlend.length) p.push({ stufe: "fehler", text: `Position ${name(x)}: {${fehlend[0]}} im Text gibt es im Mengenblatt nicht.`, position_id: x.id });
const kaputt = r?.kostenzeilen.find((z) => z.fehler);
if (kaputt && x.mit_kalkulation !== false) p.push({ stufe: "fehler", text: `Position ${name(x)}: Bezug einer Kostenzeile geht nicht (${kaputt.fehler}).`, position_id: x.id });
if (/^neue position$/i.test(x.kurztext.trim())) p.push({ stufe: "fehler", text: `Position ${name(x)}: Der Kurztext fehlt noch.`, position_id: x.id });
else if (PLATZHALTER.some((re) => re.test(x.kurztext) || re.test(langtexte[x.id] ?? ""))) {
p.push({ stufe: "fehler", text: `Position ${name(x)}: Im Text steht noch ein Platzhalter.`, position_id: x.id });
}
if (!(zahl(x.menge) > 0)) p.push({ stufe: "fehler", text: `Position ${name(x)} hat keine Menge.`, position_id: x.id });
if (!((r?.menge ?? zahl(x.menge)) > 0)) p.push({ stufe: "fehler", text: `Position ${name(x)} hat keine Menge.`, position_id: x.id });
if (r && r.ep <= 0) p.push({ stufe: "fehler", text: `Position ${name(x)} hat keinen Preis.`, position_id: x.id });
const richtig = einheitRichtig(x.einheit);
if (!richtig) p.push({ stufe: "hinweis", text: `Position ${name(x)}: Einheit „${x.einheit}“ gibt es nach DIN 18334 nicht.`, position_id: x.id });
else if (richtig !== x.einheit) p.push({ stufe: "hinweis", text: `Position ${name(x)}: Einheit „${x.einheit}“ bitte als „${richtig}“ schreiben.`, position_id: x.id });
if (r && x.ep_fest !== null && x.ep_fest !== undefined && x.ep_fest !== "" && r.kosten_je_einheit > 0 && r.ep < r.kosten_je_einheit) {
if (r && x.mit_kalkulation !== false && x.ep_fest !== null && x.ep_fest !== undefined && x.ep_fest !== "" && r.kosten_je_einheit > 0 && r.ep < r.kosten_je_einheit) {
p.push({ stufe: "hinweis", text: `Position ${name(x)}: Der feste Preis liegt unter den Kosten.`, position_id: x.id });
}
if (x.art === "alternativ" && !(x as { grundposition_id?: string | null }).grundposition_id) {
@@ -273,9 +334,10 @@ export function pruefeAngebot(
}
}
for (const k of kosten) {
if (!ids.has(k.position_id)) continue;
if (k.kostenart !== "lohn" && !(ekVon(k, { stundensaetze: { planer: 0, geselle: 0, helfer: 0 }, zuschlaege: { lohn: 0, material: 0, geraet: 0, sonstiges: 0 }, wagnis: 0, gewinn: 0, ausfall: 0 }) > 0)) {
const x = positionen.find((y) => y.id === k.position_id)!;
if (!ids.has(k.position_id) || k.aktiv === false) continue;
const x = positionen.find((y) => y.id === k.position_id)!;
if (x.mit_kalkulation === false || x.textzeile) continue;
if (k.kostenart !== "lohn" && !(ekVon(k, saetzeLeer) > 0)) {
p.push({ stufe: "hinweis", text: `Position ${name(x)}: ${KOSTENART_NAME[k.kostenart]} „${k.beschreibung || "ohne Text"}“ hat keinen Preis.`, position_id: x.id });
}
}

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

View File

@@ -0,0 +1,235 @@
// Mitgelieferte Mengenvorlagen und Musterpositionen (A23). Grundlage: die Musterformeln vom 19.10.2026
// (angebote/mengenermittlung/Musterformeln_Mengenermittlung.xlsx), die Pfettendach-Mengenermittlung aus Hennings
// Excel und die Bilder der Angebotsmaske vom 21.10.2026. Werte sind Beispiele; Querschnitte aus der Statik.
// Die Vorlagen stehen im Programm, nicht in der Datenbank: Kopieren macht daraus eine eigene, änderbare Vorlage.
import type { Blatt, BlattListe, BlattWert } from "./mengenblatt.js";
import type { Kostenart, Lohnart } from "./kalkulation.js";
export interface Ansatz {
kostenart: Kostenart;
lohnart?: Lohnart | null;
beschreibung?: string | null;
/** Kürzel oder Formel; leer = Menge der Position */
bezug?: string | null;
/** Std (Lohn) oder Menge je Bezugseinheit */
menge: number;
personen?: number;
einheit?: string | null;
/** Cent je Einheit; leer = Stundensatz der Lohnart oder noch kein Preis */
ek?: number | null;
faktor?: number;
aktiv?: boolean;
}
export interface Mengenvorlage {
id: string;
art: "mengen" | "muster";
gruppe: string;
name: string;
beschreibung?: string | null;
kurztext?: string | null;
langtext?: string | null;
einheit?: string | null;
inhalt: Blatt & { ansaetze: Ansatz[] };
/** mitgeliefert, nicht änderbar */
fest?: boolean;
reihenfolge?: number;
}
const e = (kz: string, bez: string, einheit: string, formel: string): BlattWert => ({ kz, bez, einheit, formel, eingabe: true });
const f = (kz: string, bez: string, einheit: string, formel: string): BlattWert => ({ kz, bez, einheit, formel });
const lohn = (beschreibung: string, bezug: string, menge: number, personen = 1): Ansatz => ({ kostenart: "lohn", lohnart: "geselle", beschreibung, bezug, menge, personen, einheit: "h" });
const material = (beschreibung: string, bezug: string, einheit: string, menge = 1): Ansatz => ({ kostenart: "material", beschreibung, bezug, menge, einheit });
const blatt = (werte: BlattWert[], menge: string, listen: BlattListe[] = []): Blatt => ({ werte, listen, zeilen: [], menge });
const SATTELDACH = [
e("DN", "Dachneigung", "°", "35"), e("L", "Gebäudelänge (Außenkante Wand)", "m", "10"), e("B", "Gebäudebreite (Außenkante Wand)", "m", "8"),
e("UET", "Dachüberstand Traufe, waagerecht", "m", "0,5"), e("UEO", "Dachüberstand Ortgang", "m", "0,4"), e("a", "Sparrenabstand (Achsmaß)", "m", "0,8"),
e("sb", "Sparrenbreite", "m", "0,08"), e("sh", "Sparrenhöhe", "m", "0,2"), e("LA", "Lattabstand (Ziegel)", "m", "0,33"),
e("VS", "Verschnitt Platten/Bahnen", "", "VERSCHNITT"),
f("LD", "Dachlänge inkl. Ortgang", "m", "L + 2*UEO"), f("SL", "Sparrenlänge je Seite", "m", "(B/2 + UET) / cos(DN)"),
f("FH", "Firsthöhe über Wandoberkante", "m", "B/2 * tan(DN)"), f("SA", "Sparrenanzahl beide Seiten", "St", "(aufrunden(LD/a) + 1) * 2"),
f("SLM", "Sparren gesamt", "m", "SA * SL"), f("SV", "Sparren Holzvolumen", "m³", "SLM * sb * sh"), f("AD", "Dachfläche (geneigt)", "m²", "2 * SL * LD"),
f("AG", "Grundfläche überdacht", "m²", "(B + 2*UET) * LD"), f("LAT", "Dachlattung", "m", "2 * (aufrunden(SL/LA) + 1) * LD"),
f("KL", "Konterlattung", "m", "SLM"), f("USB", "Unterspannbahn inkl. Überlappung", "m²", "AD * (1 + VS)"),
f("ZSD", "Zwischensparrendämmung", "m²", "AD * (1 - sb/a)"), f("ZSDV", "Zwischensparrendämmung Volumen", "m³", "ZSD * sh"),
f("TR", "Traufe beidseitig", "m", "2 * LD"), f("OG", "Ortgang (4 Kanten)", "m", "4 * SL"), f("FI", "First", "m", "LD"),
];
const WANDLISTE: BlattListe = {
kz: "Wand", name: "Wandliste",
spalten: [
{ kz: "Kennung", bez: "Kennung", art: "text" }, { kz: "Bezeichnung", bez: "Bezeichnung", art: "text" },
{ kz: "Breite", bez: "Breite", einheit: "m" }, { kz: "Höhe", bez: "Höhe", einheit: "m" },
// W Wand, G Giebel (Dreieck aus Breite und Höhe), F Öffnung (abgezogen ab ÖFFNUNG_AB, E28)
{ kz: "Fläche", bez: "Fläche", einheit: "m²", formel: 'wenn(Kennung = "G"; Breite * Höhe / 2; wenn(Kennung = "F"; wenn(Breite * Höhe > ÖFFNUNG_AB; -Breite * Höhe; 0); Breite * Höhe))' },
{ kz: "Schräge", bez: "Giebelrähm", einheit: "m", formel: 'wenn(Kennung = "G"; 2 * wurzel((Breite/2)^2 + Höhe^2); 0)' },
{ kz: "Umfang", bez: "Laibung", einheit: "m", formel: 'wenn(Kennung = "F"; 2 * (Breite + Höhe); 0)' },
],
zeilen: [
{ Kennung: "W", Bezeichnung: "Außenwand Nord", Breite: "10,00", Höhe: "2,75" }, { Kennung: "W", Bezeichnung: "Außenwand Süd", Breite: "10,00", Höhe: "2,75" },
{ Kennung: "W", Bezeichnung: "Außenwand Ost", Breite: "8,00", Höhe: "2,75" }, { Kennung: "W", Bezeichnung: "Außenwand West", Breite: "8,00", Höhe: "2,75" },
{ Kennung: "G", Bezeichnung: "Giebel Ost", Breite: "8,00", Höhe: "2,40" }, { Kennung: "G", Bezeichnung: "Giebel West", Breite: "8,00", Höhe: "2,40" },
{ Kennung: "F", Bezeichnung: "Fenster Küche", Breite: "1,26", Höhe: "1,385" }, { Kennung: "F", Bezeichnung: "Terrassentür", Breite: "2,01", Höhe: "2,26" },
{ Kennung: "F", Bezeichnung: "Fenster Wohnen", Breite: "2,01", Höhe: "1,385" },
],
};
const BAUTEILE: BlattListe = {
kz: "BT", name: "Bauteilliste",
spalten: [
{ kz: "Bauteil", bez: "Bauteil", art: "text" }, { kz: "b", bez: "b", einheit: "m" }, { kz: "h", bez: "h", einheit: "m" },
{ kz: "Länge", bez: "Länge", einheit: "m" }, { kz: "Anzahl", bez: "Anzahl", einheit: "St" },
{ kz: "lfm", bez: "lfm", einheit: "m", formel: "Länge * Anzahl" }, { kz: "m3", bez: "m³", einheit: "m³", formel: "b * h * lfm" },
],
zeilen: [
{ Bauteil: "Sparren", b: "0,08", h: "0,20", Länge: "10,00", Anzahl: "14" },
{ Bauteil: "Schwellen / Pfetten", b: "0,06", h: "0,12", Länge: "LP", Anzahl: "2" },
{ Bauteil: "Mittelpfette / Firstpfette", b: "0,20", h: "0,12", Länge: "LP", Anzahl: "2" },
{ Bauteil: "Stützen", b: "0,12", h: "0,12", Länge: "2,50", Anzahl: "ST" },
],
};
export const STANDARD_VORLAGEN: Mengenvorlage[] = [
{
id: "std-pfettendach", art: "muster", gruppe: "Dach", name: "Pfettendach abbinden und richten",
beschreibung: "Bauteilliste, Zeitansätze Abbund und Richten aus deiner Excel-Mengenermittlung",
kurztext: "Pfettendach abbinden und richten, KVH NSi Fi/Ta", einheit: "m",
langtext: "Dachstuhl als Pfettendach nach Statik und Werkplanung abbinden, liefern und richten. Bauholz KVH NSi Fichte/Tanne C24, technisch getrocknet, gehobelt und gefast. Verbindungsmittel und Kranstellung sind in eigenen Positionen enthalten.",
inhalt: {
...blatt([
e("LP", "Pfettenlänge", "m", "10,00"), e("SA", "Stützenabstand", "m", "2,60"), e("GP", "gestützte Pfetten", "St", "2"),
f("ST", "Anzahl Stützen", "St", "aufrunden(LP / SA) * GP"), e("VS", "Verschnitt", "", "1 + VERSCHNITT"),
f("HL", "Holz gesamt", "m", "summe(BT.lfm)"), f("HV", "Holzvolumen", "m³", "summe(BT.m3)"),
f("SPL", "Sparren", "m", 'summewenn(BT.lfm; BT.Bauteil; "Sparren")'), f("PFL", "Pfetten, Schwellen, Stützen", "m", "HL - SPL"),
], "HL", [BAUTEILE]),
ansaetze: [
lohn("Auf- und Abladen (Abbund)", "HV", 1, 2), lohn("Rüstzeit Abbund", "1", 1.5, 2), lohn("Abbund", "HL", 0.03, 2),
lohn("Auf- und Abladen (Richten)", "HV", 1, 3), lohn("Rüstzeit Richten", "1", 1.5, 3), lohn("Richten", "HL", 0.09, 3),
material("KVH 8/20 C24 NSi (Sparren)", "SPL * VS", "m"), material("KVH 6/12, 20/12, 12/12 C24 NSi", "PFL * VS", "m"),
{ kostenart: "geraet", beschreibung: "Autokran 30 t", bezug: "1", menge: 1, einheit: "Tag", aktiv: false },
],
},
},
{
id: "std-satteldach", art: "mengen", gruppe: "Dach", name: "Sparrendach / Satteldach", beschreibung: "aus Neigung, Länge und Breite; Menge = Dachfläche",
einheit: "m²", inhalt: { ...blatt(SATTELDACH, "AD"), ansaetze: [] },
},
{
id: "std-dachlattung", art: "mengen", gruppe: "Dach", name: "Dachlattung und Konterlattung", beschreibung: "Satteldach; Menge = Lattung in m",
einheit: "m", inhalt: { ...blatt(SATTELDACH, "LAT + KL"), ansaetze: [] },
},
{
id: "std-pultdach", art: "mengen", gruppe: "Dach", name: "Pultdach", beschreibung: "Menge = Dachfläche", einheit: "m²",
inhalt: {
...blatt([
e("DN", "Dachneigung", "°", "10"), e("L", "Gebäudelänge", "m", "10"), e("B", "Gebäudebreite", "m", "6"), e("UET", "Überstand Traufe", "m", "0,5"),
e("UEF", "Überstand hohe Seite", "m", "0,3"), e("UEO", "Überstand Ortgang", "m", "0,4"), e("a", "Sparrenabstand", "m", "0,8"),
e("sb", "Sparrenbreite", "m", "0,08"), e("sh", "Sparrenhöhe", "m", "0,2"),
f("LD", "Dachlänge inkl. Ortgang", "m", "L + 2*UEO"), f("PSL", "Sparrenlänge", "m", "(B + UET + UEF) / cos(DN)"),
f("PSA", "Sparrenanzahl", "St", "aufrunden(LD/a) + 1"), f("PSLM", "Sparren gesamt", "m", "PSA * PSL"), f("PSV", "Sparren Holzvolumen", "m³", "PSLM * sb * sh"),
f("PAD", "Dachfläche", "m²", "PSL * LD"), f("PH", "Höhenunterschied Traufe–First", "m", "B * tan(DN)"),
], "PAD"), ansaetze: [],
},
},
{
id: "std-walmdach", art: "mengen", gruppe: "Dach", name: "Walmdach mit Graten", beschreibung: "gleiche Neigung ringsum; Menge = Dachfläche", einheit: "m²",
inhalt: {
...blatt([
e("DN", "Dachneigung", "°", "35"), e("L", "Gebäudelänge", "m", "10"), e("B", "Gebäudebreite", "m", "8"), e("UET", "Überstand ringsum", "m", "0,5"),
f("WL", "Dachgrundriss Länge", "m", "L + 2*UET"), f("WB", "Dachgrundriss Breite", "m", "B + 2*UET"),
f("WAD", "Dachfläche Walmdach", "m²", "WL * WB / cos(DN)"), f("WFL", "Firstlänge", "m", "max(WL - WB; 0)"),
f("WGR", "Gratlänge je Grat", "m", "wurzel(2*(WB/2)^2 + (WB/2*tan(DN))^2)"), f("WGRS", "Grate gesamt", "m", "4 * WGR"),
], "WAD"), ansaetze: [],
},
},
{
id: "std-holzrahmenwand", art: "mengen", gruppe: "Wand", name: "Holzrahmenwand (Wandliste W/F/G)",
beschreibung: "W Wand, G Giebel, F Öffnung; Öffnungen ab der Vorgabe abgezogen; Menge = Wandfläche netto", einheit: "m²",
inhalt: {
...blatt([
e("RA", "Ständerabstand", "m", "0,625"), e("NE", "Wandecken und Anschlüsse", "St", "4"), e("NR", "Lagen Schwelle + Rähm", "", "2"),
e("stb", "Ständerbreite", "m", "0,06"), e("sth", "Ständertiefe", "m", "0,16"), e("VSW", "Verschnitt Beplankung", "", "0,08"),
f("LW", "Wandlänge", "m", 'summewenn(Wand.Breite; Wand.Kennung; "W")'),
f("AB", "Wandfläche brutto", "m²", 'summewenn(Wand.Fläche; Wand.Kennung; "W") + summewenn(Wand.Fläche; Wand.Kennung; "G")'),
f("AO", "Abzug Öffnungen", "m²", '-summewenn(Wand.Fläche; Wand.Kennung; "F")'), f("AN", "Wandfläche netto", "m²", "AB - AO"),
f("NOE", "Öffnungen", "St", 'anzahlwenn(Wand.Kennung; "F")'), f("STA", "Ständer", "St", "aufrunden(LW/RA) + 1 + 2*NOE + NE"),
f("SR", "Schwelle und Rähm", "m", "LW * NR"), f("GR", "Giebelrähm", "m", "summe(Wand.Schräge)"),
f("BPI", "Beplankung innen", "m²", "AN * (1 + VSW)"), f("BPA", "Beplankung außen", "m²", "AN * (1 + VSW)"),
f("DAE", "Dämmung zwischen Ständern", "m²", "AN * (1 - stb/RA)"), f("LAI", "Laibungen", "m", "summe(Wand.Umfang)"),
], "AN", [WANDLISTE]), ansaetze: [],
},
},
{
id: "std-fassade", art: "mengen", gruppe: "Wand", name: "Wandbekleidung / Fassade", beschreibung: "Lattung, Schalung, Bretter je Verlegeart; Menge = Fassadenfläche",
einheit: "m²",
inhalt: {
...blatt([
e("AF", "Fassadenfläche netto", "m²", "95"), e("HF", "Fassadenhöhe", "m", "2,75"), e("UF", "Fassadenumfang", "m", "36"), e("NEK", "Außenecken", "St", "4"),
e("aG", "Abstand Grundlattung", "m", "0,625"), e("aT", "Abstand Traglattung", "m", "0,5"), e("bD", "Deckbreite Brett", "m", "0,12"),
e("ue", "Überdeckung (Stülpschalung)", "m", "0,02"), e("abd", "Achsabstand Bodenbretter", "m", "0,18"), e("VSF", "Verschnitt Schalung", "", "0,12"),
e("BOEF", "Summe Öffnungsbreiten", "m", "9,6"), e("HOEF", "Summe Öffnungshöhen", "m", "11,4"),
f("FV", "Fassadenbahn inkl. Überlappung", "m²", "AF * 1,1"), f("GL", "Grundlattung", "m", "AF / aG"), f("TL", "Traglattung", "m", "AF / aT"),
f("ZL", "Zusatzlatten an Öffnungen", "m", "2*BOEF + 2*HOEF"), f("SCH", "Schalung mit Verschnitt", "m²", "AF * (1 + VSF)"),
f("BDS", "Boden-Deckel: Bretter", "m", "AF / abd * 2 * (1 + VSF)"), f("STS", "Stülpschalung: Bretter", "m", "AF / (bD - ue) * (1 + VSF)"),
f("NFS", "Nut und Feder: Bretter", "m", "AF / bD * (1 + VSF)"), f("EK", "Eckausbildung", "m", "NEK * HF"),
f("INS", "Insektenschutzgitter", "m", "2 * UF"), f("SCHR", "Schrauben Schalung", "St", "aufrunden(NFS / aT * 2)"),
], "AF"), ansaetze: [],
},
},
{
id: "std-carport", art: "mengen", gruppe: "Weitere", name: "Carport mit Pultdach", beschreibung: "Pfosten, Pfetten, Sparren, Kopfbänder; Menge = 1 St", einheit: "St",
inhalt: {
...blatt([
e("CL", "Länge (Pfostenachse)", "m", "6"), e("CB", "Breite (Pfostenachse)", "m", "3,5"), e("CDN", "Dachneigung", "°", "3"), e("CH", "lichte Höhe Pfosten", "m", "2,3"),
e("pA", "max. Pfostenabstand längs", "m", "3"), e("CUO", "Überstand vorn und hinten", "m", "0,3"), e("CUS", "Überstand seitlich", "m", "0,3"),
e("ca", "Sparrenabstand", "m", "0,7"), e("kb", "Kopfband Schenkellänge", "m", "0,6"), e("pq", "Pfostenquerschnitt", "m", "0,12"),
e("fq", "Pfette b", "m", "0,12"), e("fh", "Pfette h", "m", "0,2"), e("cs", "Sparren b", "m", "0,06"), e("csh", "Sparren h", "m", "0,16"),
f("CNP", "Pfosten", "St", "(aufrunden(CL/pA) + 1) * 2"), f("CPL", "Pfosten gesamt", "m", "CNP * CH"), f("CPF", "Pfetten gesamt", "m", "2 * (CL + 2*CUO)"),
f("CSA", "Sparren", "St", "aufrunden((CL + 2*CUO)/ca) + 1"), f("CSL", "Sparrenlänge", "m", "(CB + 2*CUS) / cos(CDN)"), f("CSLM", "Sparren gesamt", "m", "CSA * CSL"),
f("CKB", "Kopfbänder", "St", "2 * CNP"), f("CKBL", "Kopfbänder gesamt", "m", "CKB * kb * wurzel(2)"), f("CAD", "Dachfläche", "m²", "(CL + 2*CUO) * CSL"),
f("CBL", "Blende ringsum", "m", "2*(CL + 2*CUO) + 2*CSL"), f("CRI", "Dachrinne", "m", "CL + 2*CUO"), f("CFR", "Fallrohr", "m", "CH + 0,3"),
f("CFU", "Fundamente / Pfostenträger", "St", "CNP"), f("CHV", "Holzvolumen", "m³", "CPL*pq*pq + CPF*fq*fh + CSLM*cs*csh + CKBL*pq*pq"),
], "1"), ansaetze: [],
},
},
{
id: "std-balkendecke", art: "mengen", gruppe: "Weitere", name: "Holzbalkendecke", beschreibung: "Balkenanzahl und -volumen; Menge = Deckenfläche", einheit: "m²",
inhalt: {
...blatt([
e("DLS", "Länge quer zu den Balken", "m", "8"), e("DSW", "Spannweite (lichte Weite)", "m", "4,5"), e("DAU", "Auflagertiefe je Seite", "m", "0,15"),
e("da", "Balkenabstand", "m", "0,625"), e("db", "Balkenbreite", "m", "0,08"), e("dh", "Balkenhöhe", "m", "0,22"),
f("DBA", "Balken", "St", "aufrunden(DLS/da) + 1"), f("DBL", "Balken gesamt", "m", "DBA * (DSW + 2*DAU)"), f("DBV", "Holzvolumen", "m³", "DBL * db * dh"),
f("DFL", "Deckenfläche", "m²", "DLS * DSW"),
], "DFL"), ansaetze: [],
},
},
{
id: "std-terrasse", art: "mengen", gruppe: "Weitere", name: "Terrasse / Dielen", beschreibung: "Dielen, Unterkonstruktion, Schrauben; Menge = Fläche", einheit: "m²",
inhalt: {
...blatt([
e("TA", "Terrassenfläche", "m²", "20"), e("tb", "Dielenbreite", "m", "0,145"), e("tf", "Fugenbreite", "m", "0,007"),
e("tu", "Abstand Unterkonstruktion", "m", "0,5"), e("VST", "Verschnitt Dielen", "", "0,08"),
f("TDI", "Dielen gesamt", "m", "TA / (tb + tf) * (1 + VST)"), f("TUK", "Unterkonstruktion", "m", "TA / tu"), f("TSC", "Schrauben", "St", "aufrunden(TA / (tb + tf) / tu * 2)"),
], "TA"), ansaetze: [],
},
},
{
id: "std-abdeckblech", art: "muster", gruppe: "Klempner / Blech", name: "Abdeckblech abgekantet",
beschreibung: "Beispiel aus Bild 6: Zeitansätze bitte prüfen", einheit: "m",
kurztext: "Abdeckblech Titanzink, abgekantet, Z = {Z} m",
langtext: "Abdeckblech aus Titanzink 0,7 mm liefern, nach Aufmaß abkanten ({K} Kantungen, Zuschnitt {Z} m) und mit Haften befestigen, Stöße überlappt.",
inhalt: {
...blatt([
e("L", "Länge der Abdeckung", "m", "12,00"), e("Z", "Zuschnitt (abgewickelt)", "m", "0,30"), e("K", "Anzahl Kantungen", "St", "3"),
e("TL", "Tafellänge", "m", "2,00"), e("ÜL", "Überlappung je Stoß", "m", "0,05"),
f("STO", "Stöße", "St", "aufrunden(L / TL) - 1"), f("LG", "Länge mit Überlappung", "m", "L + STO * ÜL"), f("FL", "Blechfläche", "m²", "LG * Z"),
f("KM", "Kantmeter", "m", "L * K"), f("HA", "Haften", "St", "aufrunden(LG / 0,5)"),
], "LG"),
ansaetze: [
lohn("Abkanten", "KM", 0.02, 1), lohn("Montage", "LG", 0.15, 2),
{ ...material("Titanzinkblech 0,7 mm", "FL", "m²"), faktor: 1.1 }, material("Haften verzinkt", "HA", "St"),
],
},
},
].map((v, i) => ({ ...v, fest: true, reihenfolge: i })) as Mengenvorlage[];