@flowselections/layout-maker 1.36.7 → 1.45.8

package/dist-lib/lib/pakbonBuilder.js

@@ -75,8 +75,134 @@ export const FUST_VELD_OPTIES = [
     { value: "locatie", label: "Locatie" },
     { value: "fustsoort", label: "Tray/fustsoort" },
     { value: "planten_per_fust", label: "Planten per fust" },
+    { value: "fust_aantal", label: "Aantal fusten" },
     { value: "aantal", label: "Totaal planten" },
 ];
+/**
+ * Alle velden die op een fustregel van de afleverbrief kunnen staan. De
+ * afleverbrief beschrijft één kar, dus kar- en laagnummer horen er ook bij.
+ */
+export const FUSTREGEL_VELD_OPTIES = [
+    { value: "fustsoort", label: "Fustsoort" },
+    { value: "fusthoogte", label: "Fusthoogte" },
+    { value: "belading", label: "Belading" },
+    { value: "karnummer", label: "Karnummer" },
+    { value: "laagnummer", label: "Laag" },
+    { value: "artikelnummer", label: "Artikelnummer" },
+    { value: "artikelnaam", label: "Omschrijving" },
+    { value: "potmaat", label: "Potmaat" },
+    { value: "kleur", label: "Kleur" },
+    { value: "productgroep", label: "Productgroep" },
+    { value: "locatie", label: "Locatie" },
+    { value: "planten_per_fust", label: "Planten per fust" },
+    { value: "fust_aantal", label: "Aantal fusten" },
+    { value: "aantal", label: "Totaal planten" },
+    { value: "gewicht", label: "Gewicht" },
+];
+/** Labels van de fustregelvelden, gedeeld door scherm en afdruk. */
+export const FUSTREGEL_LABELS = Object.fromEntries(FUSTREGEL_VELD_OPTIES.map((o) => [o.value, o.label]));
+/** Velden die rechts uitgelijnd horen te staan. */
+export const FUSTREGEL_RECHTS = new Set([
+    "planten_per_fust",
+    "fust_aantal",
+    "aantal",
+    "gewicht",
+]);
+const tekst = (waarde) => String(waarde ?? "").trim();
+/**
+ * Zet de karren van een levering om naar losse fustregels. Met `comprimeren`
+ * komen identieke fusten (zelfde fustsoort, artikel, potmaat, kleur en aantal
+ * planten per fust) op één regel te staan; het aantal fusten wordt opgeteld.
+ * Zonder `comprimeren` krijgt elke losse fust een eigen regel.
+ */
+export function fustRegels(karren, opties = {}) {
+    const lijst = Array.isArray(karren) ? karren : [];
+    const regels = [];
+    for (const kar of lijst) {
+        const karnummer = tekst(kar?.karnummer ?? kar?.cart_label);
+        for (const laag of Array.isArray(kar?.lagen) ? kar.lagen : []) {
+            const fusten = Array.isArray(laag?.fusten) ? laag.fusten : [];
+            const fustInfo = (soort) => fusten.find((f) => tekst(f?.fusttype ?? f?.fustsoort).toLowerCase() === soort.toLowerCase());
+            for (const pr of Array.isArray(laag?.producten) ? laag.producten : []) {
+                const fustsoort = tekst(pr?.fustsoort) || "Onbekend";
+                const info = fustInfo(fustsoort);
+                regels.push({
+                    fustsoort,
+                    fusthoogte: tekst(info?.hoogte),
+                    belading: tekst(pr?.belading ?? info?.belading ?? laag?.belading),
+                    karnummer,
+                    laagnummer: tekst(laag?.laagnummer),
+                    artikelnummer: tekst(pr?.artikelnummer),
+                    artikelnaam: tekst(pr?.artikelnaam),
+                    potmaat: tekst(pr?.potmaat ?? laag?.potmaat),
+                    kleur: tekst(pr?.kleur),
+                    productgroep: tekst(pr?.productgroep),
+                    locatie: tekst(pr?.locatie),
+                    planten_per_fust: Number(pr?.planten_per_fust ?? 0) || 0,
+                    fust_aantal: Number(pr?.fust_aantal ?? 0) || 0,
+                    aantal: Number(pr?.aantal ?? 0) || 0,
+                    gewicht: tekst(pr?.gewicht),
+                    barcode: tekst(pr?.barcode ?? info?.barcode),
+                });
+            }
+        }
+    }
+    let uit = regels;
+    if (opties.comprimeren !== false) {
+        const map = new Map();
+        for (const r of regels) {
+            const sleutel = [
+                r.fustsoort,
+                r.fusthoogte,
+                r.artikelnummer,
+                r.artikelnaam,
+                r.potmaat,
+                r.kleur,
+                r.planten_per_fust,
+            ]
+                .join("|")
+                .toLowerCase();
+            const bestaand = map.get(sleutel);
+            if (bestaand) {
+                bestaand.fust_aantal += r.fust_aantal;
+                bestaand.aantal += r.aantal;
+                // Kar- en laagnummers van samengevoegde regels blijven zichtbaar.
+                const lagen = new Set([...bestaand.laagnummer.split(", "), r.laagnummer].filter(Boolean));
+                bestaand.laagnummer = [...lagen].join(", ");
+                if (!bestaand.locatie)
+                    bestaand.locatie = r.locatie;
+            }
+            else {
+                map.set(sleutel, { ...r });
+            }
+        }
+        uit = [...map.values()];
+    }
+    else {
+        // Zonder samenvoegen krijgt elke losse fust een eigen regel, zodat de
+        // schakelaar zichtbaar effect heeft: 8 dezelfde fusten worden 8 regels
+        // van 1 fust in plaats van één regel met 8.
+        const los = [];
+        for (const r of regels) {
+            const n = r.fust_aantal;
+            if (n > 1 && n <= 500) {
+                const perFust = r.planten_per_fust > 0 ? r.planten_per_fust : Math.round(r.aantal / n);
+                for (let i = 0; i < n; i += 1) {
+                    los.push({ ...r, fust_aantal: 1, aantal: perFust });
+                }
+            }
+            else {
+                los.push(r);
+            }
+        }
+        uit = los;
+    }
+    const sortering = opties.sortering ?? "fustsoort";
+    if (sortering !== "eigen") {
+        uit = [...uit].sort((a, b) => String(a[sortering] ?? "").localeCompare(String(b[sortering] ?? ""), "nl", { numeric: true }));
+    }
+    return uit;
+}
 const groepering = {
     key: "groepering",
     label: "Groeperen op",
@@ -209,10 +335,56 @@ export const SECTIE_REGISTER = [
             },
         ],
     },
+    {
+        type: "fustregels",
+        label: "Fustregels",
+        omschrijving: "Alle fusten van deze kar als regels, met de fustgegevens en het aantal fusten per regel.",
+        opties: [
+            {
+                key: "velden",
+                label: "Zichtbare fustgegevens",
+                type: "meerkeuze",
+                standaard: [
+                    "fustsoort",
+                    "artikelnummer",
+                    "artikelnaam",
+                    "potmaat",
+                    "planten_per_fust",
+                    "fust_aantal",
+                    "aantal",
+                ],
+                opties: FUSTREGEL_VELD_OPTIES,
+            },
+            {
+                key: "comprimeren",
+                label: "Identieke fusten samenvoegen tot één regel",
+                type: "schakelaar",
+                standaard: true,
+                hint: "Twee dezelfde fusten op de kar komen dan op één regel te staan, met 2 bij het aantal fusten.",
+            },
+            { key: "toonKoppen", label: "Kolomkoppen tonen", type: "schakelaar", standaard: true },
+            { key: "zebra", label: "Om-en-om arcering", type: "schakelaar", standaard: false },
+            { key: "randen", label: "Randen om cellen", type: "schakelaar", standaard: true },
+            { key: "toonTotaal", label: "Totaalregel tonen", type: "schakelaar", standaard: true },
+            {
+                key: "sortering",
+                label: "Sorteren op",
+                type: "keuze",
+                standaard: "fustsoort",
+                opties: [
+                    { value: "eigen", label: "Eigen volgorde" },
+                    { value: "fustsoort", label: "Fustsoort" },
+                    { value: "artikelnummer", label: "Artikelnummer" },
+                    { value: "artikelnaam", label: "Omschrijving" },
+                    { value: "locatie", label: "Locatie" },
+                ],
+            },
+        ],
+    },
     {
         type: "pickmethode",
         label: "Pickmethode",
-        omschrijving: "Bepaalt de opbouw van de pakbon: per kar (met karren en lagen) of per fust (verzamellijst).",
+        omschrijving: "Bepaalt of orders per kar, per fust of op beide manieren worden gepickt.",
         opties: [
             {
                 key: "methode",
@@ -222,8 +394,9 @@ export const SECTIE_REGISTER = [
                 opties: [
                     { value: "kar", label: "Order picken per kar" },
                     { value: "fusten", label: "Order picken per fusten (zelf karindeling maken)" },
+                    { value: "beide", label: "Order picken per kar én per fusten (karren + verzamellijst)" },
                 ],
-                hint: "Bij picken per fusten vervallen de blokken Karren, Lagen, Producten en Fusten en toont de pakbon een fustverzamellijst.",
+                hint: "Bij picken per fusten vervallen de blokken Karren, Lagen, Producten en Fusten. Bij de gecombineerde keuze bepaalt de Engine per opdracht: full_cart toont de karindeling, partial_order alleen de te verzamelen fusten.",
             },
             {
                 key: "kop",
@@ -243,12 +416,21 @@ export const SECTIE_REGISTER = [
                     "locatie",
                     "fustsoort",
                     "planten_per_fust",
+                    "fust_aantal",
                     "aantal",
                 ],
                 opties: FUST_VELD_OPTIES,
             },
             { key: "toonFusthoogte", label: "Fusthoogte en belading tonen", type: "schakelaar", standaard: true },
             { key: "toonTotaal", label: "Totaal aantal fusten tonen", type: "schakelaar", standaard: true },
+            {
+                key: "toonBarcode",
+                label: "Barcode voor afleverbrief tonen",
+                type: "schakelaar",
+                standaard: true,
+                hint: "De barcode wordt uitsluitend overgenomen uit de Engine-opdracht.",
+            },
+            { key: "barcodeHoogte", label: "Barcodehoogte (mm)", type: "getal", standaard: 15 },
         ],
     },
     {
@@ -474,6 +656,13 @@ export const SECTIE_REGISTER = [
             { key: "label", label: "Bijschrift", type: "tekst", standaard: "Voor ontvangst getekend" },
             { key: "toonNaam", label: "Naamregel", type: "schakelaar", standaard: true },
             { key: "toonDatum", label: "Datumregel", type: "schakelaar", standaard: true },
+            {
+                key: "toonBarcode",
+                label: "Barcode onderaan tonen",
+                type: "schakelaar",
+                standaard: true,
+                hint: "De barcode wordt uitsluitend overgenomen uit de Engine-opdracht.",
+            },
         ],
     },
     {
@@ -498,9 +687,9 @@ export const SECTIE_REGISTER = [
     {
         type: "barcode",
         label: "Barcode",
-        omschrijving: "Barcode met orderwaarde.",
+        omschrijving: "Scanbare barcode. Bij Engine-pakbonnen komt de waarde uit de opdracht.",
         opties: [
-            { key: "waarde", label: "Inhoud", type: "tekst", standaard: "{{order.nummer}}" },
+            { key: "waarde", label: "Inhoud", type: "tekst", standaard: "{{barcode}}" },
             { key: "hoogte", label: "Hoogte (mm)", type: "getal", standaard: 15 },
         ],
     },
@@ -555,28 +744,94 @@ export function standaardPakbonConfig() {
 export function leesPakbonConfig(config) {
     // Accepteert zowel de layout-config ({ pakbon: {...} }) als een kale
     // PakbonConfig. Zonder deze tolerantie viel de afdruk terug op de
-    // standaardsecties en verdween o.a. het documentlogo.
+    // standaardsecties en verdween o.a. het documentlogo. De sleutel
+    // "afleverbrief" wordt meegelezen zodat de printpijplijn ook
+    // afleverbrief-layouts met hun eigen secties afdrukt.
     const raw = config;
     const c = Array.isArray(raw?.secties)
         ? raw
-        : raw?.pakbon;
+        : (raw?.pakbon ?? raw?.afleverbrief);
     const secties = Array.isArray(c?.secties) ? c.secties : null;
     const logo = c?.logo ?? null;
     const basis = secties && secties.length ? { secties } : standaardPakbonConfig();
     return { ...basis, secties: migreerPickmethode(basis.secties), logo };
 }
+/** Standaardindeling van een afleverbrief: geen kar-, laag- of fustblokken. */
+export function standaardAfleverbriefConfig() {
+    return {
+        secties: [
+            "logo",
+            "bedrijfsgegevens",
+            "klantgegevens",
+            "afleveradres",
+            "orderinformatie",
+            "transportinformatie",
+            "fustregels",
+            "totalen",
+            "opmerkingen",
+            "handtekening",
+        ].map(nieuweSectie),
+    };
+}
+/**
+ * Blokken die op een afleverbrief thuishoren. Een afleverbrief beschrijft
+ * altijd precies één kar, dus kar-, laag- en pickmethodeblokken vervallen.
+ */
+export const AFLEVERBRIEF_SECTIE_TYPES = [
+    "logo",
+    "bedrijfsgegevens",
+    "klantgegevens",
+    "afleveradres",
+    "factuuradres",
+    "orderinformatie",
+    "transportinformatie",
+    "fustregels",
+    "totalen",
+    "opmerkingen",
+    "handtekening",
+    "tekstblok",
+    "qrcode",
+    "barcode",
+    "afbeelding",
+];
+/** Leest de sectie-opbouw van een afleverbrief-layout. */
+export function leesAfleverbriefConfig(config) {
+    // Eerst de eigen sleutel; oudere afleverbrief-layouts zijn per abuis via de
+    // pakbon-opbouw onder "pakbon" opgeslagen en worden hier meegelezen.
+    const raw = config;
+    const c = Array.isArray(raw?.secties)
+        ? raw
+        : (raw?.afleverbrief ?? raw?.pakbon);
+    const secties = Array.isArray(c?.secties) ? c.secties : null;
+    const logo = c?.logo ?? null;
+    const basis = secties && secties.length ? { secties } : standaardAfleverbriefConfig();
+    return { ...basis, secties: basis.secties, logo };
+}
 /** Zet de oude karren-optie "pickmethode" om naar een eigen pickmethode-blok. */
 function migreerPickmethode(secties) {
+    // Alleen relevant voor pakbonnen met een karren-blok; een afleverbrief
+    // krijgt nooit een pickmethode-kop.
     if (secties.some((s) => s.type === "pickmethode"))
         return secties;
+    if (!secties.some((s) => s.type === "karren"))
+        return secties;
     const karIndex = secties.findIndex((s) => s.type === "karren");
     const oud = karIndex >= 0 ? String(secties[karIndex].opties?.["pickmethode"] ?? "kar") : "kar";
     const blok = nieuweSectie("pickmethode");
-    blok.opties["methode"] = oud === "fusten" ? "fusten" : "kar";
+    blok.opties["methode"] = oud === "fusten" || oud === "beide" ? oud : "kar";
     const kopie = [...secties];
     kopie.splice(karIndex >= 0 ? karIndex : kopie.length, 0, blok);
     return kopie;
 }
+/** Normaliseert alleen de twee varianten uit het gedeelde Engine-contract. */
+export function pakbonLayoutVariant(value) {
+    const variant = String(value ?? "").trim().toLowerCase();
+    if (variant === "full_cart")
+        return "full_cart";
+    if (variant === "partial_order")
+        return "partial_order";
+    return null;
+}
 /** Actieve pickmethode van een pakbonconfiguratie. */
 export function pickMethode(secties) {
     const lijst = Array.isArray(secties) ? secties : [];
@@ -584,13 +839,31 @@ export function pickMethode(secties) {
     const waarde = blok
         ? String(blok.opties?.["methode"] ?? "kar")
         : String(lijst.find((s) => s.type === "karren")?.opties?.["pickmethode"] ?? "kar");
-    return waarde === "fusten" ? "fusten" : "kar";
+    if (waarde === "fusten")
+        return "fusten";
+    if (waarde === "beide")
+        return "beide";
+    return "kar";
 }
 const KAR_SECTIES = ["karren", "lagen", "producten", "fusten"];
 /** Blokken die bij de gekozen pickmethode niet van toepassing zijn. */
 export function sectieOnderdrukt(type, methode) {
     return methode === "fusten" && KAR_SECTIES.includes(type);
 }
+/**
+ * Blokken die de Engine-variant weglaat. Zonder variant blijft de editor/het
+ * losse voorbeeld compleet; een echte Engine-opdracht wordt in de wachtrij
+ * geblokkeerd totdat de variant aanwezig is.
+ */
+export function sectieOnderdruktVoorVariant(type, methode, variant) {
+    if (sectieOnderdrukt(type, methode))
+        return true;
+    if (methode !== "beide" || !variant)
+        return false;
+    if (variant === "full_cart")
+        return type === "pickmethode";
+    return type === "pickmethode" ? false : [...KAR_SECTIES, "orderregels"].includes(type);
+}
 const p = (nr, naam, potmaat, aantal, locatie, groep, kleur) => ({
     artikelnummer: nr,
     artikelnaam: naam,
@@ -651,6 +924,7 @@ export const DEMO_ORDER = {
     karren: [
         {
             karnummer: 5,
+            barcode: "VOORBEELD-KAR-05",
             route: "Route Zuid",
             chauffeur: "J. Bakker",
             gewicht: "142 kg",
@@ -687,6 +961,7 @@ export const DEMO_ORDER = {
         // ze samengevoegd tot één blok met "Deze kar 3× pakken".
         ...[6, 7, 8].map((nr) => ({
             karnummer: nr,
+            barcode: `VOORBEELD-KAR-${String(nr).padStart(2, "0")}`,
             route: "Route Zuid",
             chauffeur: "J. Bakker",
             gewicht: "118 kg",
@@ -813,8 +1088,10 @@ function laagVingerafdruk(l) {
     return [l.belading, l.potmaat, l.gewicht, l.opmerking, producten, fusten].join("#");
 }
 function karVingerafdruk(k) {
-    // karnummer bewust niet meegenomen: alleen de indeling telt
-    return [k.route, k.chauffeur, k.gewicht, k.gedeeld ? "gedeeld" : "", (k.lagen ?? []).map(laagVingerafdruk).join("~")].join("#");
+    // karnummer bewust niet meegenomen: alleen de indeling telt. Een kar met een
+    // eigen barcode of cart_id van de Engine is wél uniek en wordt nooit gebundeld.
+    const uniek = String(k.barcode ?? "") || String(k.cart_id ?? "") || String(k.cart_label ?? "");
+    return [uniek, k.route, k.chauffeur, k.gewicht, k.gedeeld ? "gedeeld" : "", (k.lagen ?? []).map(laagVingerafdruk).join("~")].join("#");
 }
 /** Groepeert identieke karren. Bij `aan = false` blijft elke kar los. */
 export function groepeerIdentiekeKarren(karren, aan) {
@@ -862,69 +1139,189 @@ export function karBundelTekst(aantal) {
 export function laagBundelTekst(aantal) {
     return `Deze laag ${aantal}×`;
 }
+const fustSleutel = (waarde) => String(waarde ?? "")
+    .trim()
+    .replace(/\s+/g, " ")
+    .toLowerCase();
 /**
  * Verzamellijst met alle fusten van een order, opgeteld per fusttype,
  * inclusief de producten die in dat fusttype gepickt moeten worden.
- * Gebruikt wanneer er per fust gepickt wordt en de gebruiker zelf de
- * karindeling maakt.
+ * Een product hoort uitsluitend bij zijn eigen fustsoort — nooit bij alle
+ * fustgroepen van de laag.
  */
 export function fustVerzamellijst(karren) {
     const lijst = Array.isArray(karren) ? karren : [];
     const map = new Map();
+    /** Expliciet door de Engine opgegeven fustaantallen per fusttype. */
+    const opgegevenAantallen = new Map();
+    const zoekGroep = (type, f) => {
+        const sleutel = fustSleutel(type) || "onbekend";
+        let groep = map.get(sleutel);
+        if (!groep) {
+            groep = {
+                fusttype: String(type ?? "").trim() || "Onbekend",
+                aantal: 0,
+                hoogte: String(f?.["hoogte"] ?? ""),
+                belading: String(f?.["belading"] ?? ""),
+                producten: [],
+            };
+            map.set(sleutel, groep);
+        }
+        else if (f) {
+            if (!groep.hoogte && f["hoogte"])
+                groep.hoogte = String(f["hoogte"]);
+            if (!groep.belading && f["belading"])
+                groep.belading = String(f["belading"]);
+        }
+        return groep;
+    };
     for (const kar of lijst) {
         for (const laag of Array.isArray(kar?.lagen) ? kar.lagen : []) {
             const producten = Array.isArray(laag?.producten) ? laag.producten : [];
-            // Zonder aparte fustlijst: fusten afleiden uit de producten, zodat een
-            // module die alleen orderregels aanlevert toch een verzamellijst krijgt.
             const opgegeven = Array.isArray(laag?.fusten) ? laag.fusten : [];
-            const afgeleid = new Map();
-            if (!opgegeven.length) {
-                for (const pr of producten) {
-                    const soort = String(pr?.fustsoort ?? "").trim() || "Onbekend";
-                    const aantal = Number(pr?.fust_aantal ?? 0) || 0;
-                    if (aantal > 0)
-                        afgeleid.set(soort, (afgeleid.get(soort) ?? 0) + aantal);
-                }
-            }
-            const fusten = opgegeven.length
-                ? opgegeven
-                : Array.from(afgeleid.entries()).map(([fusttype, aantal]) => ({ fusttype, aantal }));
-            for (const f of fusten) {
+            // Fustmetadata (hoogte/belading) en expliciete aantallen vastleggen.
+            for (const f of opgegeven) {
                 const type = String(f?.fusttype ?? f?.fustsoort ?? "Onbekend");
-                let groep = map.get(type);
-                if (!groep) {
-                    groep = {
-                        fusttype: type,
-                        aantal: 0,
-                        hoogte: String(f?.hoogte ?? ""),
-                        belading: String(f?.belading ?? ""),
-                        producten: [],
-                    };
-                    map.set(type, groep);
+                zoekGroep(type, f);
+                const sleutel = fustSleutel(type) || "onbekend";
+                opgegevenAantallen.set(sleutel, (opgegevenAantallen.get(sleutel) ?? 0) + (Number(f?.aantal ?? 0) || 0));
+            }
+            // Producten bij hun eigen fustsoort plaatsen.
+            for (const pr of producten) {
+                const type = String(pr?.fustsoort ?? "").trim() || "Onbekend";
+                const groep = zoekGroep(type);
+                const nr = String(pr?.artikelnummer ?? "");
+                const naam = String(pr?.artikelnaam ?? "");
+                const bestaand = groep.producten.find((x) => x.artikelnummer === nr && x.artikelnaam === naam);
+                const aantal = Number(pr?.aantal ?? 0) || 0;
+                const fustAantal = Number(pr?.fust_aantal ?? 0) || 0;
+                if (bestaand) {
+                    bestaand.aantal += aantal;
+                    bestaand.fust_aantal += fustAantal;
                 }
-                groep.aantal += Number(f?.aantal ?? 0);
-                for (const pr of producten) {
-                    const nr = String(pr?.artikelnummer ?? "");
-                    const bestaand = groep.producten.find((x) => x.artikelnummer === nr);
-                    if (bestaand) {
-                        bestaand.aantal += Number(pr?.aantal ?? 0);
-                    }
-                    else {
-                        groep.producten.push({
-                            artikelnummer: nr,
-                            artikelnaam: String(pr?.artikelnaam ?? ""),
-                            potmaat: String(pr?.potmaat ?? ""),
-                            kleur: String(pr?.kleur ?? ""),
-                            productgroep: String(pr?.productgroep ?? ""),
-                            locatie: String(pr?.locatie ?? ""),
-                            fustsoort: String(pr?.fustsoort ?? ""),
-                            planten_per_fust: Number(pr?.planten_per_fust ?? 0),
-                            aantal: Number(pr?.aantal ?? 0),
-                        });
-                    }
+                else {
+                    groep.producten.push({
+                        artikelnummer: nr,
+                        artikelnaam: naam,
+                        potmaat: String(pr?.potmaat ?? ""),
+                        kleur: String(pr?.kleur ?? ""),
+                        productgroep: String(pr?.productgroep ?? ""),
+                        locatie: String(pr?.locatie ?? ""),
+                        fustsoort: String(pr?.fustsoort ?? ""),
+                        planten_per_fust: Number(pr?.planten_per_fust ?? 0) || 0,
+                        fust_aantal: fustAantal,
+                        aantal,
+                    });
                 }
             }
         }
     }
-    return [...map.values()].sort((a, b) => a.fusttype.localeCompare(b.fusttype));
+    const groepen = [...map.entries()].map(([sleutel, groep]) => {
+        const uitProducten = groep.producten.reduce((n, p) => n + p.fust_aantal, 0);
+        const expliciet = opgegevenAantallen.get(sleutel) ?? 0;
+        // Engine-opgave is leidend; anders tellen we de fusten van de producten op.
+        groep.aantal = expliciet > 0 ? expliciet : uitProducten;
+        return groep;
+    });
+    return groepen
+        .filter((g) => g.producten.length > 0 || g.aantal > 0)
+        .sort((a, b) => a.fusttype.localeCompare(b.fusttype));
+}
+/**
+ * Voorbeeld van een deelkar (niet-volle kar): alleen een deel van de fusten,
+ * zonder karindeling. Uitsluitend bedoeld voor het voorbeeld in de builder —
+ * echte opdrachten krijgen hun gegevens van de Logistics Engine.
+ */
+export function deelkarVoorbeeldOrder(order = DEMO_ORDER) {
+    const eerste = order.karren[0];
+    const laag = eerste?.lagen?.[0];
+    if (!eerste || !laag)
+        return order;
+    return {
+        ...order,
+        karren: [
+            {
+                ...eerste,
+                gedeeld: true,
+                barcode: "VOORBEELD-DEELKAR",
+                lagen: [{ ...laag, producten: laag.producten.slice(0, 1), fusten: laag.fusten?.slice(0, 1) ?? [] }],
+            },
+        ],
+    };
+}
+// --- restpakbon (deelkar) ---------------------------------------------------
+/** Restregels zoals de Logistics Engine ze meestuurt onder `cart.cart_items`. */
+export function deelkarRegels(order) {
+    const o = (order && typeof order === "object" ? order : {});
+    const cart = (o["cart"] && typeof o["cart"] === "object" ? o["cart"] : {});
+    const lijst = cart["cart_items"] ?? cart["items"];
+    return Array.isArray(lijst) ? lijst : [];
+}
+const tekstWaarde = (waarde) => waarde === undefined || waarde === null ? "" : String(waarde).trim();
+/**
+ * Beperkt een order tot de restregels van één deelkar. Alleen wat de Engine
+ * als `cart.cart_items` meestuurt komt op de restpakbon te staan; nooit de
+ * volledige karinhoud. Wordt gedeeld door voorbeeld, PDF en print, zodat de
+ * drie weergaven niet uiteen kunnen lopen.
+ */
+export function beperkTotDeelkar(order) {
+    const regels = deelkarRegels(order);
+    if (!regels.length)
+        return order;
+    const o = (order && typeof order === "object" ? order : {});
+    const cart = (o["cart"] && typeof o["cart"] === "object" ? o["cart"] : {});
+    const karren = Array.isArray(o["karren"]) ? o["karren"] : [];
+    const cartId = tekstWaarde(cart["cart_id"]);
+    const basisKar = (cartId ? karren.find((k) => tekstWaarde(k["cart_id"]) === cartId) : undefined) ??
+        karren[0] ??
+        {};
+    const producten = regels.map((raw) => {
+        const item = raw;
+        return {
+            artikelnummer: tekstWaarde(item["artikelnummer"] ?? item["artikelcode"]),
+            artikelnaam: tekstWaarde(item["artikelnaam"] ?? item["product_name"] ?? item["omschrijving"]),
+            potmaat: tekstWaarde(item["potmaat"]),
+            aantal: Number(item["aantal"] ?? item["quantity"] ?? 0) || 0,
+            belading: tekstWaarde(item["belading"]),
+            barcode: tekstWaarde(item["barcode"]),
+            opmerking: tekstWaarde(item["opmerking"]),
+            locatie: tekstWaarde(item["locatie"]),
+            gewicht: tekstWaarde(item["gewicht"]),
+            productgroep: tekstWaarde(item["productgroep"]),
+            kleur: tekstWaarde(item["kleur"]),
+            fust_aantal: Number(item["fust_aantal"] ?? item["aantal_fusten"] ?? 0) || 0,
+            fustsoort: tekstWaarde(item["fustsoort"] ?? item["fusttype"]),
+            planten_per_fust: Number(item["planten_per_fust"] ?? 0) || 0,
+        };
+    });
+    // Fusten per soort optellen uit dezelfde restregels, zodat de verzamellijst
+    // en de totalen nooit meer tonen dan er nog verzameld moet worden.
+    const fustMap = new Map();
+    for (const pr of producten) {
+        const sleutel = pr.fustsoort.toLowerCase() || "onbekend";
+        const bestaand = fustMap.get(sleutel);
+        if (bestaand)
+            bestaand.aantal += pr.fust_aantal;
+        else
+            fustMap.set(sleutel, {
+                fusttype: pr.fustsoort || "Onbekend",
+                aantal: pr.fust_aantal,
+                hoogte: "",
+                belading: pr.belading,
+                barcode: "",
+            });
+    }
+    const laag = {
+        laagnummer: 1,
+        belading: "",
+        potmaat: "",
+        gewicht: "",
+        opmerking: "",
+        producten,
+        fusten: [...fustMap.values()].filter((f) => f.aantal > 0),
+    };
+    return {
+        ...o,
+        karren: [{ ...basisKar, lagen: [laag] }],
+    };
 }