@flowselections/logistiek-engine 1.0.1

package/dist-lib/lib/loadCarrierPlanner.js

@@ -0,0 +1,374 @@
+// ============================================================================
+// src/lib/loadCarrierPlanner.ts — beladingindeling voor ALLE ladingdragers
+// ============================================================================
+// Pure functie: geen database, geen netwerk, volledig synchroon en
+// deterministisch. Zelfde algoritme als de oorspronkelijke karrenindeling,
+// maar met een capaciteitsprofiel per ladingdrager als extra invoer.
+//
+// Twee onafhankelijke capaciteitsassen per ladingdrager:
+//   - verticaal  : totalHeightPct <= 100
+//   - horizontaal: crateShare per laag <= 1
+// ============================================================================
+export const LOAD_CARRIER_PLANNER_VERSION = 2;
+const EPS = 1e-9;
+function clampInt(value, min) {
+    const n = typeof value === "string" ? Number(value) : value;
+    return Math.max(min, Math.round(Number.isFinite(n) ? n : min));
+}
+/** Effectieve lagen: het minimum van de productbelading en de ladingdrager. */
+function effectiveLayers(item, carrier) {
+    const carrierLayers = Math.max(1, Math.round(carrier.layers_per_carrier || 1));
+    if (carrier.capacity_model === "single" || carrier.capacity_model === "none")
+        return 1;
+    return Math.max(1, Math.min(item.layers_per_cart, carrierLayers));
+}
+/** Effectieve fusten per laag: begrensd door de ladingdrager. */
+function effectiveCratesPerLayer(item, carrier) {
+    const cap = carrier.max_crates_per_layer;
+    const base = Math.max(1, item.crates_per_layer);
+    if (typeof cap === "number" && cap > 0)
+        return Math.max(1, Math.min(base, Math.round(cap)));
+    return base;
+}
+// ---------------------------------------------------------------------------
+// Plaatsingsregels
+// ---------------------------------------------------------------------------
+function placeAsFreshLayer(cart, batch, batchIdx, crates) {
+    if (cart.totalHeightPct + batch.layerHeightPct > 100 + EPS)
+        return false;
+    cart.layers.push({
+        heightPct: batch.layerHeightPct,
+        crateShare: crates / batch.cratesPerLayer,
+        entries: [{ batchIdx, crates }],
+    });
+    cart.totalHeightPct += batch.layerHeightPct;
+    return true;
+}
+function placeInLayer(cart, batch, batchIdx, crates, r) {
+    const partyShare = crates / batch.cratesPerLayer;
+    const maxShare = r.opts.maxPartySharePerLayerPct / 100;
+    // REGEL 1 — één partij mag nooit meer dan X% van een laag beslaan
+    if (partyShare > maxShare + EPS)
+        return false;
+    // REGEL 2 — never-mix producten en niet-mengbare ladingdragers
+    const neverMix = r.opts.carrier.allow_mixing === false ||
+        (batch.input.product_id ? r.opts.neverMixProductIds.has(batch.input.product_id) : false);
+    if (neverMix)
+        return false;
+    for (const layer of cart.layers) {
+        // REGEL 3 — max aantal verschillende beladingen per laag
+        if (layer.entries.length >= r.opts.maxBeladingenPerLayer)
+            continue;
+        // REGEL 4 — dezelfde partij niet twee keer in dezelfde laag
+        if (layer.entries.some((e) => e.batchIdx === batchIdx))
+            continue;
+        // REGEL 5 — vloeroppervlak van de laag mag niet over 100%
+        if (layer.crateShare + partyShare > 1 + EPS)
+            continue;
+        // REGEL 6 — hoogte: bij mengen telt de HOOGSTE partij
+        const newHeight = Math.max(layer.heightPct, batch.layerHeightPct);
+        const heightDelta = newHeight - layer.heightPct;
+        if (cart.totalHeightPct + heightDelta > 100 + EPS)
+            continue;
+        layer.entries.push({ batchIdx, crates });
+        layer.crateShare += partyShare;
+        layer.heightPct = newHeight;
+        cart.totalHeightPct += heightDelta;
+        return true;
+    }
+    return false;
+}
+/** Extra grenzen die niet over hoogte of oppervlak gaan. */
+function acceptsBatch(cart, batch, crates, r) {
+    const carrier = r.opts.carrier;
+    const orderId = batch.input.order_id ?? null;
+    if (orderId && !cart.orderIds.has(orderId) && r.opts.maxOrders && cart.orderIds.size >= r.opts.maxOrders) {
+        return false;
+    }
+    const customerId = batch.input.customer_id ?? null;
+    if (customerId &&
+        !cart.customerIds.has(customerId) &&
+        r.opts.maxCustomers &&
+        cart.customerIds.size >= r.opts.maxCustomers) {
+        return false;
+    }
+    if (typeof carrier.max_boxes === "number" && carrier.max_boxes > 0) {
+        if (cart.boxes + crates > carrier.max_boxes)
+            return false;
+    }
+    if (typeof carrier.max_weight_kg === "number" && carrier.max_weight_kg > 0) {
+        const perCrate = Number(batch.input.weight_per_crate ?? 0) || 0;
+        if (perCrate > 0 && cart.weightKg + perCrate * crates > carrier.max_weight_kg + EPS)
+            return false;
+    }
+    return true;
+}
+function registerPlacement(cart, batch, crates) {
+    if (batch.input.order_id)
+        cart.orderIds.add(batch.input.order_id);
+    if (batch.input.customer_id)
+        cart.customerIds.add(batch.input.customer_id);
+    cart.boxes += crates;
+    cart.weightKg += (Number(batch.input.weight_per_crate ?? 0) || 0) * crates;
+}
+function tryPlaceBatch(cart, batch, batchIdx, r) {
+    const cpl = batch.cratesPerLayer;
+    let placed = 0;
+    let remaining = batch.cratesRemaining;
+    // 1) zo veel mogelijk VOLLE eigen lagen
+    while (remaining >= cpl && cart.totalHeightPct + batch.layerHeightPct <= 100 + EPS) {
+        if (!acceptsBatch(cart, batch, cpl, r))
+            break;
+        if (!placeAsFreshLayer(cart, batch, batchIdx, cpl))
+            break;
+        registerPlacement(cart, batch, cpl);
+        remaining -= cpl;
+        placed += cpl;
+    }
+    // 2) het restant: eerst bijmengen, anders eigen (deels lege) laag
+    if (remaining > 0) {
+        const partial = Math.min(remaining, Math.ceil(cpl * 0.5));
+        if (acceptsBatch(cart, batch, partial, r) && placeInLayer(cart, batch, batchIdx, partial, r)) {
+            registerPlacement(cart, batch, partial);
+            remaining -= partial;
+            placed += partial;
+        }
+        else if (acceptsBatch(cart, batch, remaining, r) && placeAsFreshLayer(cart, batch, batchIdx, remaining)) {
+            registerPlacement(cart, batch, remaining);
+            placed += remaining;
+            remaining = 0;
+        }
+    }
+    return placed;
+}
+// ---------------------------------------------------------------------------
+// Samenvatten
+// ---------------------------------------------------------------------------
+function summarizeCart(cart, rests, cartNumber, r) {
+    const byBatch = new Map();
+    for (const layer of cart.layers) {
+        const shareSum = layer.entries.reduce((s, e) => s + e.crates, 0);
+        for (const e of layer.entries) {
+            const cur = byBatch.get(e.batchIdx) ?? { crates: 0, layerFraction: 0, heightPct: 0 };
+            const ratio = shareSum > 0 ? e.crates / shareSum : 0;
+            cur.crates += e.crates;
+            cur.layerFraction += ratio;
+            cur.heightPct += layer.heightPct * ratio;
+            byBatch.set(e.batchIdx, cur);
+        }
+    }
+    const totalHeight = cart.totalHeightPct;
+    const items = [];
+    let weight = 0;
+    for (const [batchIdx, agg] of byBatch) {
+        const input = rests[batchIdx].input;
+        const perCrate = Number(input.weight_per_crate ?? 0) || 0;
+        weight += perCrate * agg.crates;
+        items.push({
+            order_item_id: input.order_item_id,
+            order_id: input.order_id ?? null,
+            product_id: input.product_id,
+            product_name: input.product_name,
+            crates: agg.crates,
+            plants: agg.crates * input.plants_per_crate,
+            boxes: agg.crates,
+            weight_kg: perCrate > 0 ? Math.round(perCrate * agg.crates * 100) / 100 : null,
+            plants_per_crate: input.plants_per_crate,
+            crates_per_layer: rests[batchIdx].cratesPerLayer,
+            layers_per_cart: Math.max(1, Math.round(100 / rests[batchIdx].layerHeightPct)),
+            layer_fraction: totalHeight > 0 ? agg.heightPct / totalHeight : 0,
+            layer_share_pct: agg.heightPct,
+        });
+    }
+    return {
+        cart_number: cartNumber,
+        carrier_type: r.opts.carrier.code,
+        carrier_type_id: r.opts.carrier.id ?? null,
+        source: "auto",
+        is_complete: Math.abs(cart.totalHeightPct - 100) < 1e-6,
+        occupancy_pct: Math.round(cart.totalHeightPct * 100) / 100,
+        total_layers_used: cart.layers.length,
+        max_layers: Math.max(1, Math.round(r.opts.carrier.layers_per_carrier || 1)),
+        weight_kg: weight > 0 ? Math.round(weight * 100) / 100 : null,
+        items,
+    };
+}
+function newCart() {
+    return {
+        layers: [],
+        totalHeightPct: 0,
+        boxes: 0,
+        weightKg: 0,
+        orderIds: new Set(),
+        customerIds: new Set(),
+    };
+}
+function fullCart(input, crates, cratesPerLayer, layers, cartNumber, r) {
+    const perCrate = Number(input.weight_per_crate ?? 0) || 0;
+    return {
+        cart_number: cartNumber,
+        carrier_type: r.opts.carrier.code,
+        carrier_type_id: r.opts.carrier.id ?? null,
+        source: "auto",
+        is_complete: true,
+        occupancy_pct: 100,
+        total_layers_used: layers,
+        max_layers: Math.max(1, Math.round(r.opts.carrier.layers_per_carrier || 1)),
+        weight_kg: perCrate > 0 ? Math.round(perCrate * crates * 100) / 100 : null,
+        items: [
+            {
+                order_item_id: input.order_item_id,
+                order_id: input.order_id ?? null,
+                product_id: input.product_id,
+                product_name: input.product_name,
+                crates,
+                plants: crates * input.plants_per_crate,
+                boxes: crates,
+                weight_kg: perCrate > 0 ? Math.round(perCrate * crates * 100) / 100 : null,
+                plants_per_crate: input.plants_per_crate,
+                crates_per_layer: cratesPerLayer,
+                layers_per_cart: layers,
+                layer_fraction: 1,
+                layer_share_pct: 100,
+            },
+        ],
+    };
+}
+function sortInputs(items, sortOrder) {
+    const list = [...items];
+    switch (sortOrder) {
+        case "customer":
+            return list.sort((a, b) => String(a.customer_id ?? "").localeCompare(String(b.customer_id ?? "")));
+        case "product":
+            return list.sort((a, b) => a.product_name.localeCompare(b.product_name));
+        case "size":
+            return list.sort((a, b) => b.plants_per_crate - a.plants_per_crate);
+        case "none":
+            return list;
+        default:
+            return list;
+    }
+}
+// ---------------------------------------------------------------------------
+// Hoofdfunctie
+// ---------------------------------------------------------------------------
+export function planLoadUnits(inputs, options) {
+    const carrier = options.carrier;
+    const r = {
+        opts: {
+            carrier,
+            maxPartySharePerLayerPct: options.maxPartySharePerLayerPct ?? 50,
+            maxBeladingenPerLayer: options.maxBeladingenPerLayer ?? 2,
+            neverMixProductIds: options.neverMixProductIds ?? new Set(),
+            maxOrders: options.maxOrders ?? null,
+            maxCustomers: options.maxCustomers ?? null,
+            oneCustomerPerLayer: options.oneCustomerPerLayer ?? false,
+            ownCarrierFromLayers: options.ownCarrierFromLayers ?? null,
+            sortOrder: options.sortOrder ?? "none",
+        },
+    };
+    const warnings = [];
+    const carts = [];
+    const items = sortInputs((Array.isArray(inputs) ? inputs : [])
+        .map((i) => ({
+        ...i,
+        plants: Math.max(0, Math.round(Number(i.plants) || 0)),
+        plants_per_crate: clampInt(i.plants_per_crate, 1),
+        crates_per_layer: clampInt(i.crates_per_layer, 1),
+        layers_per_cart: clampInt(i.layers_per_cart, 1),
+    }))
+        .filter((i) => i.plants > 0), r.opts.sortOrder);
+    // --- Model "none": elke partij is één losse eenheid, geen menging ---------
+    if (carrier.capacity_model === "none") {
+        let n = 0;
+        for (const it of items) {
+            const crates = Math.ceil(it.plants / it.plants_per_crate);
+            carts.push(fullCart(it, crates, crates, 1, ++n, r));
+        }
+        return { carts, warnings };
+    }
+    const rests = [];
+    let cartNumber = 0;
+    // --- STAP A: volledige ladingdragers per artikel --------------------------
+    for (const it of items) {
+        const layers = effectiveLayers(it, carrier);
+        const cpl = effectiveCratesPerLayer(it, carrier);
+        let cratesPerCart = cpl * layers;
+        if (typeof carrier.max_boxes === "number" && carrier.max_boxes > 0) {
+            cratesPerCart = Math.min(cratesPerCart, carrier.max_boxes);
+        }
+        const totalCrates = Math.ceil(it.plants / it.plants_per_crate);
+        const fullCarts = Math.floor(totalCrates / cratesPerCart);
+        let remainderCrates = totalCrates - fullCarts * cratesPerCart;
+        for (let c = 0; c < fullCarts; c++) {
+            carts.push(fullCart(it, cratesPerCart, cpl, layers, ++cartNumber, r));
+        }
+        // Partij die zelfstandig genoeg volle lagen vult krijgt een eigen drager.
+        const own = r.opts.ownCarrierFromLayers;
+        if (own && own > 0 && remainderCrates >= cpl * own) {
+            const usedLayers = Math.ceil(remainderCrates / cpl);
+            const unit = fullCart(it, remainderCrates, cpl, usedLayers, ++cartNumber, r);
+            unit.is_complete = false;
+            unit.occupancy_pct = Math.round((usedLayers / layers) * 10000) / 100;
+            unit.items[0].layer_share_pct = unit.occupancy_pct;
+            carts.push(unit);
+            remainderCrates = 0;
+        }
+        if (remainderCrates > 0) {
+            rests.push({
+                input: it,
+                cratesRemaining: remainderCrates,
+                layerHeightPct: 100 / layers,
+                cratesPerLayer: cpl,
+                beladingKey: `${it.plants_per_crate}x${cpl}x${layers}`,
+            });
+        }
+    }
+    // --- Sorteren van de restpartijen: first-fit decreasing -------------------
+    rests.sort((a, b) => {
+        if (a.beladingKey !== b.beladingKey)
+            return a.beladingKey.localeCompare(b.beladingKey);
+        return b.cratesRemaining - a.cratesRemaining;
+    });
+    // --- STAP B: de hoofdlus --------------------------------------------------
+    const openCarts = [];
+    for (let bi = 0; bi < rests.length; bi++) {
+        const batch = rests[bi];
+        let guard = 0;
+        while (batch.cratesRemaining > 0 && guard++ < 1000) {
+            let placed = 0;
+            for (const cart of openCarts) {
+                placed = tryPlaceBatch(cart, batch, bi, r);
+                if (placed > 0) {
+                    batch.cratesRemaining -= placed;
+                    break;
+                }
+            }
+            if (placed === 0) {
+                const cart = newCart();
+                placed = tryPlaceBatch(cart, batch, bi, r);
+                if (placed === 0) {
+                    warnings.push(`Partij "${batch.input.product_name}" past niet volgens de veiligheidsregels van ${carrier.name} — geplaatst als losse ladingdrager.`);
+                    cart.layers.push({
+                        heightPct: 100,
+                        crateShare: 1,
+                        entries: [{ batchIdx: bi, crates: batch.cratesRemaining }],
+                    });
+                    cart.totalHeightPct = 100;
+                    registerPlacement(cart, batch, batch.cratesRemaining);
+                    placed = batch.cratesRemaining;
+                }
+                openCarts.push(cart);
+                batch.cratesRemaining -= placed;
+            }
+        }
+    }
+    for (const cart of openCarts) {
+        carts.push(summarizeCart(cart, rests, ++cartNumber, r));
+    }
+    // Doornummeren zodat de volgorde altijd 1..n is.
+    carts.forEach((c, idx) => {
+        c.cart_number = idx + 1;
+    });
+    return { carts, warnings };
+}