347 lines
21 KiB
JavaScript
347 lines
21 KiB
JavaScript
/*!
|
||
* Tectum
|
||
* Copyright © 2026 Machiel Heinen.
|
||
* Alle rechten voorbehouden. Gebruik uitsluitend met schriftelijke toestemming.
|
||
* Zie LICENTIE.md.
|
||
*/
|
||
// ============================================================
|
||
// cost/cost-model.js — CostModel: ENIGE bron van de kostenberekening
|
||
// (materiaal + arbeid). Geen DOM. Rekent op de doorgerekende woning
|
||
// (HouseModel.computeParts + computeTotals) met de kosten/tijden uit
|
||
// COST_DEFAULTS (cost-defaults.js) plus de eigen instellingen van de
|
||
// gebruiker (localStorage, instellingenvenster cost-settings.js).
|
||
//
|
||
// Opbouw: per element (wandstuk, vloer, dak, woning-breed) regels
|
||
// { cat, act, label, qty, unit, mat (€), sec (s arbeid) }
|
||
// cat = materiaalgroep, act = werkzaamheid. Opgeteld per element, per unit
|
||
// en voor de woning; daarna opslagen (indirecte uren, materiaal, marge, btw).
|
||
//
|
||
// Plain script, geladen na house-model.js en cost-defaults.js.
|
||
// ============================================================
|
||
|
||
window.CostModel = (() => {
|
||
const STORAGE_KEY = 'tectum.costs';
|
||
const listeners = [];
|
||
|
||
// ------------------------------------------------------------
|
||
// Instellingen: standaard (COST_DEFAULTS) + eigen waarden (localStorage).
|
||
// values = { groep: { sleutel: waarde } }.
|
||
// ------------------------------------------------------------
|
||
function defaultValues() {
|
||
const v = {};
|
||
Object.entries(window.COST_DEFAULTS).forEach(([g, grp]) => {
|
||
v[g] = {};
|
||
Object.entries(grp.items).forEach(([k, it]) => { v[g][k] = it.value; });
|
||
});
|
||
return v;
|
||
}
|
||
// Alleen bekende sleutels met een geldig type overnemen.
|
||
function mergeValues(base, over) {
|
||
const v = JSON.parse(JSON.stringify(base));
|
||
Object.entries(over || {}).forEach(([g, items]) => {
|
||
const grp = window.COST_DEFAULTS[g];
|
||
if (!grp || !items || typeof items !== 'object') return;
|
||
Object.entries(items).forEach(([k, val]) => {
|
||
const it = grp.items[k];
|
||
if (!it) return;
|
||
if (it.options ? Object.prototype.hasOwnProperty.call(it.options, val) : typeof val === 'number' && isFinite(val)) v[g][k] = val;
|
||
});
|
||
});
|
||
return v;
|
||
}
|
||
function readOverrides() {
|
||
try { return JSON.parse(localStorage.getItem(STORAGE_KEY) || '{}') || {}; } catch (e) { return {}; }
|
||
}
|
||
function getSettings() { return mergeValues(defaultValues(), readOverrides()); }
|
||
// Slaat alleen de afwijkingen van de standaard op.
|
||
function saveSettings(values) {
|
||
const def = defaultValues(), diff = {};
|
||
Object.entries(mergeValues(def, values)).forEach(([g, items]) => Object.entries(items).forEach(([k, val]) => {
|
||
if (val !== def[g][k]) (diff[g] = diff[g] || {})[k] = val;
|
||
}));
|
||
try { localStorage.setItem(STORAGE_KEY, JSON.stringify(diff)); } catch (e) { /* geen opslag: alleen deze sessie */ }
|
||
listeners.forEach(fn => fn());
|
||
}
|
||
function resetSettings() { saveSettings(defaultValues()); }
|
||
function onChange(fn) { listeners.push(fn); return () => { const i = listeners.indexOf(fn); if (i >= 0) listeners.splice(i, 1); }; }
|
||
|
||
// Export/import (JSON-bestand): altijd de volledige set waarden.
|
||
function exportJson(values) {
|
||
return { type: 'tectum-costs', version: 1, exportedAt: new Date().toISOString(), values: mergeValues(defaultValues(), values) };
|
||
}
|
||
function importJson(obj) {
|
||
if (!obj || obj.type !== 'tectum-costs' || typeof obj.values !== 'object') throw new Error('geen Tectum-kostenbestand');
|
||
return mergeValues(defaultValues(), obj.values);
|
||
}
|
||
|
||
// ------------------------------------------------------------
|
||
// Berekening
|
||
// ------------------------------------------------------------
|
||
const CAT_ORDER = ['Hout', 'Schroeven', 'Plaatwerk', 'Isolatie', 'Gevel', 'Dak', 'Vloer', 'Kozijnen', 'Verlichting'];
|
||
const ACT_ORDER = ['Zagen', 'Regelwerk monteren', 'Wanden plaatsen', 'Plaatwerk', 'Isoleren', 'Gevel', 'Latwerk', 'Dak', 'Vloer', 'Kozijnen', 'Verlichting'];
|
||
const VERTICAL_KINDS = ['verticale balk', 'kreupele stijl'];
|
||
const DORPEL_KINDS = ['bovendorpel', 'onderdorpel'];
|
||
|
||
function compute(parts, totals, settings) {
|
||
const S = settings || getSettings();
|
||
const elements = [];
|
||
const newEl = (element, label, unit) => { const el = { element, label, unit, lines: [] }; elements.push(el); return el; };
|
||
// sec = tijd voor één persoon; crew = personeel bij die stap (standaard
|
||
// de gemiddelde bezetting per productiestap). Opgeslagen sec = manuren.
|
||
const add = (el, cat, act, label, qty, unit, mat, sec, crew) => {
|
||
if (!(qty > 0)) return;
|
||
const c = sec ? (crew !== undefined ? crew : S.arbeid.bezetting) : 0;
|
||
// clock = doorlooptijd van de stap (s), voor afschrijving/huisvesting.
|
||
el.lines.push({ cat, act, label, qty, unit, mat: mat || 0, sec: (sec || 0) * c, clock: c ? sec : 0, crew: c });
|
||
};
|
||
|
||
// --- Gedeelde rekenregels ---
|
||
const Z = S.zagen, V = S.verbinden, P = S.plaat;
|
||
const sawFactor = Z.methode === 'hand' ? Z.handFactor : 1;
|
||
// Zaagtijd van één stuk (s): handling + sneden (+ extra per schuine snede).
|
||
// saw: totalen voor het zaagoverzicht (robot- en handtijd, los van de keuze).
|
||
const saw = { pieces: 0, cuts: 0, angled: 0, robotSec: 0 };
|
||
const sawSec = (cutAngles, count = 1) => {
|
||
const ca = cutAngles || [0, 0], angled = ca.filter(a => a !== 0).length;
|
||
const robot = Z.robotStuk + ca.length * Z.robotSnede + angled * Z.robotSchuin;
|
||
saw.pieces += count; saw.cuts += count * ca.length; saw.angled += count * angled; saw.robotSec += count * robot;
|
||
return count * robot * sawFactor;
|
||
};
|
||
const sawLabel = Z.methode === 'hand' ? 'Zagen (handmatig)' : 'Zagen (robot)';
|
||
const jointSec = V.eersteSchroef + Math.max(0, V.schroevenPerVerbinding - 1) * V.volgendeSchroef;
|
||
// Constructie monteren (lijmen + schroeven): schroeftijd x V.monteerFactor,
|
||
// met V.personeel man (manuren), op het dak factor V.dakFactor (roof = true).
|
||
const addJoints = (el, joints, label, roof) => {
|
||
const n = joints * V.schroevenPerVerbinding;
|
||
const f = V.monteerFactor * (roof ? V.dakFactor : 1);
|
||
add(el, 'Schroeven', 'Regelwerk monteren', `${label} monteren, lijmen + schroeven (${joints} verb. × ${V.schroevenPerVerbinding}, ×${V.monteerFactor}${roof ? `, dak ×${V.dakFactor}` : ''})`, n, 'st.', n * V.prijsPer1000 / 1000, joints * jointSec * f, V.personeel);
|
||
};
|
||
// Plaat: materiaal + montage + plaatschroeven.
|
||
const addSheet = (el, cat, label, m2, priceM2, montageSecM2) => {
|
||
if (!(m2 > 0)) return;
|
||
add(el, cat, 'Plaatwerk', label, m2, 'm²', m2 * priceM2, m2 * montageSecM2);
|
||
const n = Math.ceil(m2 * P.schroevenPerM2);
|
||
add(el, 'Schroeven', 'Plaatwerk', `Plaatschroeven ${label.toLowerCase()}`, n, 'st.', n * P.plaatschroefPer1000 / 1000, n * P.tijdPerPlaatschroef);
|
||
};
|
||
// Snijverlies wandbalken (inkoop in handelslengtes, hele woning).
|
||
const waste = totals.purchaseStockMM > 0 ? totals.purchaseWasteMM / Math.max(1, totals.purchaseStockMM - totals.purchaseWasteMM) : 0;
|
||
|
||
const fmtM = (v) => v.toLocaleString('nl-NL', { maximumFractionDigits: 1 });
|
||
// --- Wandstukken (buiten + binnen/naad) ---
|
||
const seenOpenings = new Set(); // naadwand: openingen één keer (beide delen hebben dezelfde deur)
|
||
function wallElement(p, unitId) {
|
||
const el = newEl(p.element, p.label, unitId);
|
||
const bom = WallModel.computeBOM(p.config, p.frame);
|
||
const woodM3 = bom.reduce((a, b) => a + b.width * b.depth * b.length, 0) / 1e9;
|
||
add(el, 'Hout', 'Zagen', `Regelwerk ${bom.length} st. (incl. ${Math.round(waste * 100)}% snijverlies)`, woodM3 * (1 + waste), 'm³', woodM3 * (1 + waste) * S.hout.constructieM3, 0);
|
||
const cuts = bom.reduce((a, b) => a + (b.cutAngles || [0, 0]).length, 0);
|
||
add(el, 'Hout', 'Zagen', `${sawLabel}: ${bom.length} stuks`, cuts, 'sneden', 0, bom.reduce((a, b) => a + sawSec(b.cutAngles), 0));
|
||
const verticals = bom.filter(b => VERTICAL_KINDS.includes(b.kind)).length;
|
||
const dorpels = bom.filter(b => DORPEL_KINDS.includes(b.kind)).length;
|
||
const topPlates = bom.filter(b => b.kind === 'bovenregel').length;
|
||
addJoints(el, 2 * verticals + 2 * dorpels + Math.max(0, topPlates - 1), 'Stijlen/dorpels');
|
||
// Dubbele stijlen (deur, hoek: twee stijlen tegen elkaar): verticaal
|
||
// elke V.dubbelAfstand mm een schroef over de gezamenlijke lengte.
|
||
const studs = bom.filter(b => VERTICAL_KINDS.includes(b.kind)).sort((a, b) => a.x - b.x);
|
||
let dblScrews = 0, dblPairs = 0;
|
||
for (let i = 1; i < studs.length; i++) {
|
||
const a = studs[i - 1], b = studs[i];
|
||
if (b.x - a.x > (a.width + b.width) / 2 + 1) continue;
|
||
const ov = Math.min(a.y + a.length / 2, b.y + b.length / 2) - Math.max(a.y - a.length / 2, b.y - b.length / 2);
|
||
if (ov <= 0) continue;
|
||
dblPairs++;
|
||
dblScrews += Math.max(2, Math.floor(ov / V.dubbelAfstand));
|
||
}
|
||
add(el, 'Schroeven', 'Regelwerk monteren', `Dubbele stijlen ${dblPairs}× (schroef elke ${V.dubbelAfstand} mm, ×${V.monteerFactor})`, dblScrews, 'st.',
|
||
dblScrews * V.prijsPer1000 / 1000, dblScrews * V.volgendeSchroef * V.monteerFactor, V.personeel);
|
||
const M = S.montage;
|
||
add(el, 'Hout', 'Wanden plaatsen', `Plaatsen en vastzetten (${M.muurVastzetten} min)`, 1, 'sectie', 0, M.muurVastzetten * 60, M.muurPersoneel);
|
||
|
||
const st = p.stats || {};
|
||
addSheet(el, 'Plaatwerk', 'Spaanplaat', (st.spaanplaatAreaM2 || 0) + (st.spaanplaatBuitenAreaM2 || 0), P.spaanplaatM2, P.spaanplaatMontage);
|
||
addSheet(el, 'Plaatwerk', 'Cementplaat', (st.cementplaatAreaM2 || 0) + (st.trasraamAreaM2 || 0), P.cementplaatM2, P.cementplaatMontage);
|
||
const I = S.isolatie;
|
||
const wool = (p.specs && p.specs.voidVolumeM3) || 0;
|
||
add(el, 'Isolatie', 'Isoleren', 'Glaswol', wool, 'm³', wool * I.glaswolM3, wool * I.glaswolMontage);
|
||
const stoneIso = (st.stoneIsolatieM3 || 0) + (st.trasraamIsolatieM3 || 0);
|
||
add(el, 'Isolatie', 'Gevel', 'Isolatieblok steen', stoneIso, 'm³', stoneIso * I.steenIsolatieM3, 0);
|
||
|
||
const G = S.gevel;
|
||
const doek = st.doekAreaM2 || 0;
|
||
// Montage per strekkende meter wand (breedte van het stuk).
|
||
const doekM = doek > 0 ? p.place.width / 1000 : 0;
|
||
add(el, 'Gevel', 'Gevel', `Vochtdoek (${fmtM(doekM)} m¹ wand)`, doek, 'm²', doek * G.vochtdoekM2, doekM * G.vochtdoekMontageM);
|
||
// Rabat over het doek, boven het trasraam (gevelvlak uit WallModel).
|
||
const rabat = p.buitenMateriaal === 'vochtdoek' ? (st.rabatAreaM2 || 0) : 0;
|
||
add(el, 'Gevel', 'Gevel', 'Rabat', rabat, 'm²', rabat * G.rabatM2, rabat * G.rabatMontage);
|
||
const steen = (st.stoneAreaM2 || 0) + (st.trasraamStoneAreaM2 || 0);
|
||
add(el, 'Gevel', 'Gevel', 'Steenstrips', steen, 'm²', steen * G.steenM2, steen * G.steenMontage);
|
||
const latM = st.battenLengthM || 0;
|
||
add(el, 'Hout', 'Latwerk', `Latwerk (${st.battenCount || 0} latten inkoop, ${st.battenPieces || 0} stukken)`, latM, 'm', latM * S.hout.latwerkM,
|
||
(st.battenPieces || 0) * S.hout.latStukMontage + latM * S.hout.latMeterMontage);
|
||
|
||
const K = S.kozijnen;
|
||
const opKey = p.seam ? `iw${p.id}` : null;
|
||
if (!opKey || !seenOpenings.has(opKey)) {
|
||
if (opKey) seenOpenings.add(opKey);
|
||
(p.config.openings || []).forEach(op => {
|
||
if (op.type === 'raam') {
|
||
const m2 = WallModel.openingArea(op) / 1e6;
|
||
add(el, 'Kozijnen', 'Kozijnen', `Raam ${op.w}×${op.h}`, m2, 'm²', m2 * K.raamM2, K.montage);
|
||
} else {
|
||
add(el, 'Kozijnen', 'Kozijnen', `${op.type === 'voordeur' ? 'Voordeur' : 'Deur'} ${op.w}×${op.h}`, 1, 'st.', op.type === 'voordeur' ? K.voordeur : K.deur, K.montage);
|
||
}
|
||
});
|
||
}
|
||
}
|
||
parts.units.forEach(u => u.walls.forEach(w => w.pieces.forEach(p => wallElement(p, u.id))));
|
||
parts.interior.forEach(p => wallElement(p, p.seamUnit || null));
|
||
|
||
// --- Vloer- en dakbalken (balklaag: zagen + verbindingen) ---
|
||
function joistLayer(el, cd, angleDeg, what, roof) {
|
||
const rims = ['front', 'back'].filter(k => cd.rims && cd.rims[k]).length;
|
||
const n = cd.joists.length;
|
||
const ang = angleDeg || 0;
|
||
add(el, 'Hout', 'Zagen', `${sawLabel}: ${what}balken ${n} + kopbalken ${rims}`, 2 * (n + rims), 'sneden', 0, sawSec([ang, ang], n) + sawSec([0, 0], rims));
|
||
addJoints(el, n * V.verbindingenPerVloerbalk, `${what}balken`, roof);
|
||
}
|
||
|
||
parts.units.forEach(u => {
|
||
// Vloer
|
||
const fl = newEl(u.floorElement, `Unit ${u.id} vloer`, u.id);
|
||
const fs = u.floorSpecs;
|
||
add(fl, 'Hout', 'Zagen', 'Vloerbalken', fs.joistWoodM3, 'm³', fs.joistWoodM3 * S.hout.constructieM3, 0);
|
||
joistLayer(fl, u.floorData.calcData, 0, 'Vloer');
|
||
addSheet(fl, 'Plaatwerk', 'OSB vloer', fs.osbAreaM2, P.osbM2, P.osbMontage);
|
||
add(fl, 'Isolatie', 'Isoleren', 'Glaswol vloer', fs.voidM3, 'm³', fs.voidM3 * S.isolatie.glaswolM3, fs.voidM3 * S.isolatie.glaswolMontage);
|
||
// Afwerking: vloer min de voetafdruk van de wanden op deze unit.
|
||
const foot = u.walls.reduce((a, w) => a + w.pieces.filter(p => !p.place.baseY).reduce((b, p) => b + p.place.width * p.place.thickness, 0), 0)
|
||
+ parts.interior.filter(p => p.seamUnit === u.id).reduce((a, p) => a + p.place.width * p.place.thickness, 0);
|
||
const finM2 = Math.max(0, u.rect.W * u.rect.D - foot) / 1e6;
|
||
add(fl, 'Vloer', 'Vloer', 'Vloerafwerking', finM2, 'm²', finM2 * S.vloer.afwerkingM2, finM2 * S.vloer.afwerkingMontage);
|
||
|
||
// Dak
|
||
const rf = newEl(`${u.id}-D`, `Unit ${u.id} dak`, u.id);
|
||
const rs = u.roof.specs, D = S.dak;
|
||
add(rf, 'Hout', 'Zagen', 'Dakbalken', rs.joistWoodM3, 'm³', rs.joistWoodM3 * S.hout.constructieM3, 0);
|
||
u.roof.planes.forEach((pl, i) => joistLayer(rf, pl.data.calcData, Math.round(Math.abs(pl.theta || 0) * 180 / Math.PI * 10) / 10, u.roof.planes.length > 1 ? `Dak ${i + 1} ` : 'Dak', true));
|
||
// Wolfsdak: bovenste deel (sporen, hoekkepers, nokbalk, kopbalken).
|
||
const cap = u.roof.unitRoof && u.roof.unitRoof.cap;
|
||
if (cap) {
|
||
const n = cap.beams.length;
|
||
add(rf, 'Hout', 'Zagen', `${sawLabel}: wolfseinden ${n} balken`, 2 * n, 'sneden', 0, cap.beams.reduce((t, bm) => t + sawSec([bm.angle, bm.angle], 1), 0));
|
||
addJoints(rf, n * V.verbindingenPerVloerbalk, 'wolfseindbalken', true);
|
||
}
|
||
addSheet(rf, 'Plaatwerk', 'OSB plafond', rs.osbAreaM2, P.osbM2, P.osbMontage);
|
||
add(rf, 'Isolatie', 'Isoleren', 'Glaswol dak', rs.voidM3, 'm³', rs.voidM3 * S.isolatie.glaswolM3, rs.voidM3 * S.isolatie.glaswolMontage);
|
||
add(rf, 'Dak', 'Dak', 'Dakleer (EPDM)', rs.dakleerM2 || 0, 'm²', (rs.dakleerM2 || 0) * D.dakleerM2, (rs.dakleerM2 || 0) * D.dakleerMontage);
|
||
add(rf, 'Dak', 'Dak', 'Riet', rs.rietM2 || 0, 'm²', (rs.rietM2 || 0) * D.rietM2, (rs.rietM2 || 0) * D.rietMontage);
|
||
});
|
||
|
||
// --- Woning-breed: dakrand, sandwichpanelen, verlichting ---
|
||
const wo = newEl('WON', 'Woning (dakrand, fundering, verlichting)', null);
|
||
const D = S.dak;
|
||
if (totals.roofEdge) {
|
||
const e = totals.roofEdge;
|
||
add(wo, 'Dak', 'Dak', `Boeideel ${e.fasciaHeight} mm`, e.fasciaLengthM, 'm', e.fasciaLengthM * D.boeideelM, e.fasciaLengthM * D.boeideelMontage);
|
||
add(wo, 'Dak', 'Dak', 'Onderplaat boeideel', e.soffitM2, 'm²', e.soffitM2 * D.onderplaatM2, e.soffitM2 * D.onderplaatMontage);
|
||
add(wo, 'Dak', 'Dak', `Daktrim ${e.trimHeight} mm`, e.trimLengthM, 'm', e.trimLengthM * D.daktrimM, e.trimLengthM * D.daktrimMontage);
|
||
}
|
||
if (parts.sandwich) {
|
||
const sw = parts.sandwich;
|
||
add(wo, 'Vloer', 'Vloer', `Sandwichpanelen (${sw.panelCount} platen)`, sw.areaM2, 'm²', sw.areaM2 * S.vloer.sandwichM2, sw.panelCount * S.vloer.sandwichMontage);
|
||
}
|
||
const L = S.verlichting, lm = totals.lamps;
|
||
add(wo, 'Verlichting', 'Verlichting', 'Gevellampen', lm.total, 'st.', lm.total * L.gevellamp, lm.total * L.montage);
|
||
const spots = totals.roofEdge ? totals.roofEdge.spots : 0;
|
||
add(wo, 'Verlichting', 'Verlichting', 'Boeideel-spots', spots, 'st.', spots * L.boeideelSpot, spots * L.montage);
|
||
add(wo, 'Verlichting', 'Verlichting', 'Binnenspots', lm.indoor, 'st.', lm.indoor * L.binnenspot, lm.indoor * L.montage);
|
||
|
||
// --- Optellen ---
|
||
const sumLines = (lines) => lines.reduce((a, l) => ({ mat: a.mat + l.mat, sec: a.sec + l.sec, clock: a.clock + l.clock }), { mat: 0, sec: 0, clock: 0 });
|
||
elements.forEach(el => Object.assign(el, sumLines(el.lines)));
|
||
const byKey = (key, order) => {
|
||
const m = new Map();
|
||
elements.forEach(el => el.lines.forEach(l => {
|
||
const r = m.get(l[key]) || { name: l[key], mat: 0, sec: 0 };
|
||
r.mat += l.mat; r.sec += l.sec;
|
||
m.set(l[key], r);
|
||
}));
|
||
return Array.from(m.values()).sort((a, b) => order.indexOf(a.name) - order.indexOf(b.name));
|
||
};
|
||
// Kostprijs van materiaal + directe arbeidstijd (s), overal dezelfde
|
||
// regels: materiaal + verlies + klein materiaal; uren + indirect + QA
|
||
// tegen het uurloon (manuren); afschrijving/slijtage/huisvesting per
|
||
// productie-uur = doorlooptijd (klokuren, niet x personeel) + indirect, zonder QA.
|
||
const O = S.opslag, B = S.bedrijf, A = S.arbeid;
|
||
const perHour = B.machines + B.slijtage + B.huisvesting;
|
||
const split = (sec) => {
|
||
const direct = sec / 3600, indirect = direct * A.toeslagUren / 100;
|
||
const qa = (direct + indirect) * A.qa / 100; // QA: % van de totale werktijd
|
||
return { direct, indirect, qa, total: direct + indirect + qa };
|
||
};
|
||
const prodHours = (clock) => clock / 3600 * (1 + A.toeslagUren / 100);
|
||
const costOf = (r) => mat0(r.mat) + split(r.sec).total * A.uurloon + prodHours(r.clock) * perHour;
|
||
const mat0 = (mat) => mat * (1 + (O.verlies + O.klein) / 100);
|
||
elements.forEach(el => { el.kostprijs = costOf(el); });
|
||
|
||
const units = parts.units.map(u => {
|
||
const r = Object.assign({ id: u.id }, sumLines(elements.filter(el => el.unit === u.id).flatMap(el => el.lines)));
|
||
r.transport = B.transportUnit;
|
||
r.kostprijs = costOf(r) + r.transport;
|
||
return r;
|
||
});
|
||
const rest = sumLines(elements.filter(el => el.unit === null).flatMap(el => el.lines));
|
||
units.push(Object.assign({ id: null, transport: 0 }, rest, { kostprijs: costOf(rest) + B.kraan }));
|
||
|
||
const all = sumLines(elements.flatMap(el => el.lines));
|
||
const h = split(all.sec);
|
||
h.prod = prodHours(all.clock);
|
||
const n = parts.units.length;
|
||
const pct = (v) => String(v).replace('.', ',') + '%';
|
||
const eur0 = (v) => eur(v);
|
||
const posts = [
|
||
['Materiaal', all.mat],
|
||
[`Materiaalverlies ${pct(O.verlies)}`, all.mat * O.verlies / 100],
|
||
[`Klein materiaal ${pct(O.klein)}`, all.mat * O.klein / 100],
|
||
[`Arbeid ${uur(h.total)} manuur × ${eur0(A.uurloon)} (incl. bezetting, indirect en QA)`, h.total * A.uurloon],
|
||
[`Afschrijving machines ${uur(h.prod)} productie-uur × ${eur(B.machines, 2)}`, h.prod * B.machines],
|
||
[`Slijtage gereedschap ${uur(h.prod)} productie-uur × ${eur(B.slijtage, 2)}`, h.prod * B.slijtage],
|
||
[`Huisvesting productiehal ${uur(h.prod)} productie-uur × ${eur(B.huisvesting, 2)}`, h.prod * B.huisvesting],
|
||
[`Transport ${n} unit${n === 1 ? '' : 's'} × ${eur0(B.transportUnit)}`, n * B.transportUnit],
|
||
['Kraan plaatsen', B.kraan]
|
||
];
|
||
const kostprijs = posts.reduce((a, p) => a + p[1], 0);
|
||
const algemeen = kostprijs * O.algemeen / 100;
|
||
const marge = (kostprijs + algemeen) * O.marge / 100;
|
||
const exBtw = kostprijs + algemeen + marge;
|
||
const btw = exBtw * O.btw / 100;
|
||
// Overzicht als rijen (kaart en PDF): sub = subtotaal.
|
||
const rows = posts.filter(p => p[1] > 0).map(([label, amount]) => ({ label, amount }))
|
||
.concat([
|
||
{ label: 'Kostprijs', amount: kostprijs, sub: true },
|
||
{ label: `Algemene kosten ${pct(O.algemeen)}`, amount: algemeen },
|
||
{ label: `Marge ${pct(O.marge)}`, amount: marge },
|
||
{ label: 'Totaal excl. btw', amount: exBtw, sub: true },
|
||
{ label: `Btw ${pct(O.btw)}`, amount: btw }
|
||
]);
|
||
return {
|
||
settings: S, elements, units,
|
||
saw: Object.assign(saw, { handSec: saw.robotSec * Z.handFactor, method: Z.methode }),
|
||
categories: byKey('cat', CAT_ORDER), activities: byKey('act', ACT_ORDER),
|
||
summary: { mat: all.mat, hoursDirect: h.direct, hoursIndirect: h.indirect, hoursQa: h.qa, hours: h.total, kostprijs, exBtw, btw, inclBtw: exBtw + btw, rows }
|
||
};
|
||
}
|
||
|
||
// Bedrag als "€ 1.234" (of met decimalen).
|
||
function eur(n, decimals = 0) {
|
||
return '€ ' + n.toLocaleString('nl-NL', { minimumFractionDigits: decimals, maximumFractionDigits: decimals });
|
||
}
|
||
// Uren als decimaal getal, bijv. "12,5".
|
||
function uur(hours) {
|
||
return hours.toLocaleString('nl-NL', { minimumFractionDigits: 1, maximumFractionDigits: 1 });
|
||
}
|
||
|
||
return { STORAGE_KEY, defaultValues, getSettings, saveSettings, resetSettings, onChange, exportJson, importJson, compute, eur, uur };
|
||
})();
|