@flowselections/logistiek-engine 1.0.53 → 1.0.90

package/dist-lib/lib/flowRoute.js

@@ -14,6 +14,7 @@
 import { WIZARD_STEPS } from "./ruleEngineWizard";
 import { FLOW_NODE, bronNodeVoor } from "./flowNodes";
 import { vakUitleg } from "./vakUitleg";
+import { stopReden, samenkomstStop } from "./stopReden";
 const STEP_IDS = WIZARD_STEPS.map((s) => s.id);
 const STAP = {
     combineren: STEP_IDS[0] ?? "orders_combineren",
@@ -30,6 +31,7 @@ export const REASON_LABEL = {
     werktijden_ontbreken: "Werktijden van de klant ontbreken",
     fust_onbekend: "Fusttype onbekend",
     geen_regels: "Order heeft geen regels",
+    dubbele_regels: "Order heeft dubbele bestelregels; er is niets ingedeeld",
 };
 export function redenTekst(code, error) {
     const label = code ? REASON_LABEL[code] ?? code.replace(/_/g, " ") : null;
@@ -152,6 +154,15 @@ export function stapLabel(stepId) {
     return WIZARD_STEPS.find((s) => s.id === stepId)?.label ?? stepId;
 }
 // ── Route over de kaart leggen ──────────────────────────────────────────────
+/**
+ * Twee extra vakjes tussen "Pickstations en documenten" en "Controle en
+ * afmelden": die horen niet bij de instellingenstappen, maar hebben wel een
+ * vaste plek in de volgorde.
+ */
+const EXTRA_STAP_INDEX = {
+    "stap:pakbon_geprint": STEP_IDS.indexOf(STAP.stations) + 0.3,
+    "stap:kar_afgemeld": STEP_IDS.indexOf(STAP.stations) + 0.6,
+};
 /** Stapvolgorde-index van een knoop; -1 = vóór de eerste stap; 99 = einde. */
 function stapIndex(node, byId) {
     if (!node)
@@ -160,6 +171,9 @@ function stapIndex(node, byId) {
         return 99;
     if (node.id.startsWith("__"))
         return -1;
+    const extra = EXTRA_STAP_INDEX[node.id];
+    if (extra !== undefined)
+        return extra;
     const m = /^(?:samen:)?stap:(.+)$/.exec(node.id);
     if (m)
         return STEP_IDS.indexOf(m[1]);
@@ -172,6 +186,117 @@ function stapIndex(node, byId) {
     }
     return -1;
 }
+/** Zet op het laatste vakje van de route altijd een reden waarom het daar stopt. */
+function markeerEindpunt(markers, routeNodes, routeEdges, byId, groepen, stand) {
+    const heeftVervolg = new Set(routeEdges.filter((e) => routeNodes.has(e.to)).map((e) => e.from));
+    const kandidaten = [...routeNodes].filter((id) => id !== "__start" && !heeftVervolg.has(id));
+    const eindpunten = new Set(kandidaten);
+    if (kandidaten.length === 0)
+        return { eind: null, eindpunten };
+    let eind = null;
+    let besteIdx = -Infinity;
+    let besteTijd = "";
+    for (const id of kandidaten) {
+        const idx = stapIndex(byId.get(id), byId);
+        const tijd = groepen?.get(id)?.laatste ?? "";
+        if (idx > besteIdx || (idx === besteIdx && tijd > besteTijd)) {
+            eind = id;
+            besteIdx = idx;
+            besteTijd = tijd;
+        }
+    }
+    if (!eind)
+        return { eind: null, eindpunten };
+    const bestaand = markers.get(eind);
+    const stop = stopReden({
+        nodeId: eind,
+        groep: groepen?.get(eind) ?? null,
+        stand,
+        verouderd: bestaand?.verouderd === true,
+    });
+    markers.set(eind, {
+        kind: bestaand?.kind ?? (stop.soort === "mislukt" ? "stuck" : stop.soort === "klaar" ? "done" : "busy"),
+        text: bestaand?.text ?? stop.titel,
+        ...bestaand,
+        eindpunt: true,
+        // Een wachtpunt heeft al zijn eigen stopreden; die blijft staan.
+        stop: bestaand?.stop ?? stop,
+    });
+    return { eind, eindpunten };
+}
+/**
+ * Samenkomstpunten waar de route nog niet voorbij mag: de ingestelde
+ * voorwaarde ("alle lijnen" of een verplichte lijn) is nog niet gehaald.
+ * Loopt de maximale wachttijd af, dan gaat de route alsnog verder; zo kan een
+ * tak die nooit gebeurt de flow niet voor altijd vastzetten.
+ */
+function bepaalWachtpunten(nodes, edges, routeNodes, routeEdges, echt, markers) {
+    const wachtpunten = new Set();
+    const nu = Date.now();
+    for (const node of nodes) {
+        const wacht = node.wacht;
+        if (node.kind !== "merge" || !wacht || !routeNodes.has(node.id))
+            continue;
+        const inkomend = edges.filter((e) => e.kind === "flow" && e.to === node.id && e.state !== "disabled");
+        const nodig = wacht.wanneer === "specifiek"
+            ? inkomend.filter((e) => e.id === wacht.verplichteLijn)
+            : inkomend;
+        if (nodig.length === 0)
+            continue;
+        const naam = (id) => nodes.find((n) => n.id === id)?.label || "een eerdere tak";
+        const klaar = [];
+        const open = [];
+        const mislukt = [];
+        let eerste = "";
+        for (const e of nodig) {
+            const groep = echt.get(e.from);
+            const gelopen = routeEdges.has(e.id) || !!groep;
+            if (groep?.status === "mislukt")
+                mislukt.push(naam(e.from));
+            if (gelopen) {
+                klaar.push(naam(e.from));
+                const t = groep?.laatste ?? "";
+                if (t && (!eerste || t < eerste))
+                    eerste = t;
+            }
+            else {
+                open.push(naam(e.from));
+            }
+        }
+        if (open.length === 0 && mislukt.length === 0)
+            continue;
+        // Vangnet: na de maximale wachttijd loopt de route alsnog door.
+        const start = eerste ? new Date(eerste).getTime() : NaN;
+        const verlopen = Number.isFinite(start) && nu - start > wacht.maxWachtMinuten * 60000;
+        if (verlopen && mislukt.length === 0) {
+            const bestaand = markers.get(node.id);
+            markers.set(node.id, {
+                kind: bestaand?.kind ?? "busy",
+                text: "Doorgegaan na maximale wachttijd",
+                beslissing: "Doorgegaan na maximale wachttijd",
+                waarom: `Er is langer dan ${wacht.maxWachtMinuten} minuten gewacht op ${open.join(", ")}; de flow is daarna verdergegaan.`,
+                feiten: [`Voorwaarde: ${wacht.label}`, `Nog niet klaar: ${open.join(", ")}`],
+                ...bestaand,
+            });
+            continue;
+        }
+        wachtpunten.add(node.id);
+        markers.set(node.id, {
+            kind: mislukt.length > 0 ? "stuck" : "busy",
+            text: mislukt.length > 0 ? "Verplichte tak is mislukt" : "Wacht op andere takken",
+            beslissing: mislukt.length > 0 ? "Verplichte tak is mislukt" : "Wacht op andere takken",
+            eindpunt: true,
+            stop: samenkomstStop({
+                wachtOp: open,
+                mislukt,
+                voorwaarde: wacht.label,
+                maxWachtMinuten: wacht.maxWachtMinuten,
+            }),
+            feiten: klaar.length > 0 ? [`Al klaar: ${klaar.join(", ")}`] : [],
+        });
+    }
+    return wachtpunten;
+}
 /**
  * Maakt een kopie van de kaart waarin alleen de gelopen route "active" is.
  * Knopen/pijlen die de order (nog) niet heeft bereikt worden "possible".
@@ -180,12 +305,12 @@ function stapIndex(node, byId) {
  * komt dan uit wat de Engine heeft vastgelegd. De heuristiek hieronder blijft
  * de terugval voor oudere gebeurtenissen zonder vakje.
  */
-export function applyRoute(tree, route, groepen) {
+export function applyRoute(tree, route, groepen, stand) {
     const markers = new Map();
     const nodes = Array.isArray(tree?.nodes) ? tree.nodes : [];
     const edges = Array.isArray(tree?.edges) ? tree.edges : [];
     if (!route)
-        return { tree: { nodes, edges }, markers };
+        return { tree: { nodes, edges }, markers, wachtpunten: new Set() };
     const echt = groepen && groepen.size > 0 ? groepen : null;
     const byId = new Map(nodes.map((n) => [n.id, n]));
     const maxIdx = route.reached.reduce((m, id) => Math.max(m, STEP_IDS.indexOf(id)), -1);
@@ -212,25 +337,218 @@ export function applyRoute(tree, route, groepen) {
             return bronNode === FLOW_NODE.bronFloriday;
         return true;
     };
-    /** Ligt dit vakje op de reis? Echte gebeurtenissen gaan vóór de heuristiek. */
+    const demote = (s) => (s === "active" ? "possible" : s);
+    // ── Route uit echte gebeurtenissen: altijd een aaneengesloten pad ──────────
+    if (echt) {
+        // Alleen lijnen die volgens de huidige werkwijze bestaan en bij deze bron horen.
+        const bruikbaar = (e) => e.kind === "flow" &&
+            e.state === "active" &&
+            bronOk(e.from) &&
+            bronOk(e.to) &&
+            byId.get(e.from)?.state === "active" &&
+            byId.get(e.to)?.state === "active";
+        const uit = new Map();
+        for (const e of edges) {
+            if (!bruikbaar(e))
+                continue;
+            const lijst = uit.get(e.from);
+            if (lijst)
+                lijst.push({ to: e.to, edgeId: e.id });
+            else
+                uit.set(e.from, [{ to: e.to, edgeId: e.id }]);
+        }
+        // Kortste pad vanaf het startvakje naar elk bereikbaar vakje.
+        const vorige = new Map();
+        const gezien = new Set(["__start"]);
+        const rij = ["__start"];
+        for (let i = 0; i < rij.length; i++) {
+            const huidig = rij[i];
+            for (const stap of uit.get(huidig) ?? []) {
+                if (gezien.has(stap.to))
+                    continue;
+                gezien.add(stap.to);
+                vorige.set(stap.to, { from: huidig, edgeId: stap.edgeId });
+                rij.push(stap.to);
+            }
+        }
+        // Bewijs: vakjes waarvoor daadwerkelijk iets is vastgelegd, plus het bronvakje.
+        const bewijs = new Set([...echt.keys()]);
+        if (bronNode)
+            bewijs.add(bronNode);
+        const routeNodes = new Set(["__start"]);
+        const routeEdges = new Set();
+        const onbereikbaar = new Set();
+        for (const id of bewijs) {
+            if (!byId.has(id) || !gezien.has(id)) {
+                onbereikbaar.add(id);
+                continue;
+            }
+            let stap = id;
+            while (stap && stap !== "__start") {
+                routeNodes.add(stap);
+                const p = vorige.get(stap);
+                if (!p)
+                    break;
+                routeEdges.add(p.edgeId);
+                stap = p.from;
+            }
+        }
+        // Samenkomstpunten met een eigen voorwaarde kunnen de route hier stoppen.
+        const wachtpunten = bepaalWachtpunten(nodes, edges, routeNodes, routeEdges, echt, markers);
+        // Een stap die nog loopt (wachtend/waarschuwing) houdt alleen de volgende
+        // echte stap tegen. De keuze-, uitkomst- en samenkomstvakjes van diezelfde
+        // stap staan al vast en blijven dus wel blauw.
+        const lopend = new Set();
+        for (const g of echt.values()) {
+            if (g.status !== "wachtend" && g.status !== "waarschuwing")
+                continue;
+            if (!routeNodes.has(g.nodeId))
+                continue;
+            lopend.add(g.nodeId);
+        }
+        const isStapVak = (id) => id.startsWith("stap:") || byId.get(id)?.kind === "step";
+        /** Een volgende stap mag alsnog blauw worden als die zelf geslaagd is. */
+        const isGeslaagdeStap = (id) => echt.get(id)?.status === "geslaagd";
+        // Voorbij een samenkomst-wachtpunt loopt de blauwe route niet meer; het
+        // grijze vervolg daarachter blijft gewoon staan (er wordt niets weggesnoeid).
+        const kandidaatEdges = edges.filter((e) => routeEdges.has(e.id) && !wachtpunten.has(e.from));
+        const verdereStap = new Map();
+        for (const e of kandidaatEdges) {
+            const lijst = verdereStap.get(e.from);
+            if (lijst)
+                lijst.push({ to: e.to, id: e.id });
+            else
+                verdereStap.set(e.from, [{ to: e.to, id: e.id }]);
+        }
+        const routeTot = new Set(["__start"]);
+        const routeEdgeIds = new Set();
+        /** Per knoop: welke lopende stappen liggen er vóór dit punt op de route? */
+        const naLopend = new Map();
+        /** Lopende stappen waar de route toch langs mocht (latere stap is geslaagd). */
+        const doorgelaten = new Set();
+        const rijRoute = ["__start"];
+        for (let i = 0; i < rijRoute.length; i++) {
+            const huidig = rijRoute[i];
+            const oorsprongen = new Set(naLopend.get(huidig) ?? []);
+            if (lopend.has(huidig))
+                oorsprongen.add(huidig);
+            const na = oorsprongen.size > 0;
+            for (const { to: volgend, id: edgeId } of verdereStap.get(huidig) ?? []) {
+                // Na een lopende stap stopt de blauwe route bij het eerstvolgende
+                // stapvakje — tenzij van die stap zelf iets geslaagds is vastgelegd.
+                if (na && isStapVak(volgend)) {
+                    if (!isGeslaagdeStap(volgend))
+                        continue;
+                    for (const o of oorsprongen)
+                        doorgelaten.add(o);
+                    routeEdgeIds.add(edgeId);
+                    if (!routeTot.has(volgend)) {
+                        routeTot.add(volgend);
+                        rijRoute.push(volgend);
+                    }
+                    continue;
+                }
+                routeEdgeIds.add(edgeId);
+                let veranderd = false;
+                if (na) {
+                    const set = naLopend.get(volgend) ?? new Set();
+                    for (const o of oorsprongen) {
+                        if (!set.has(o)) {
+                            set.add(o);
+                            veranderd = true;
+                        }
+                    }
+                    naLopend.set(volgend, set);
+                }
+                if (routeTot.has(volgend)) {
+                    if (veranderd)
+                        rijRoute.push(volgend);
+                    continue;
+                }
+                routeTot.add(volgend);
+                rijRoute.push(volgend);
+            }
+        }
+        const routeEdgeLijst = kandidaatEdges.filter((e) => routeEdgeIds.has(e.id));
+        // Alleen lopende stappen waar de route écht stopt gelden als wachtpunt.
+        for (const id of lopend)
+            if (!doorgelaten.has(id))
+                wachtpunten.add(id);
+        const newNodes = nodes.map((n) => routeTot.has(n.id) && n.state === "active"
+            ? { ...n, route: true }
+            : { ...n, state: demote(n.state), route: false });
+        const newEdges = edges.map((e) => routeEdgeIds.has(e.id) ? { ...e, route: true } : { ...e, state: demote(e.state), route: false });
+        /** Waar hoort bewijs heen dat niet meer op de kaart bereikbaar is? */
+        const vervangend = (id) => {
+            const n = byId.get(id);
+            const stapId = n?.stepId ? `stap:${n.stepId}` : null;
+            if (stapId && routeTot.has(stapId))
+                return stapId;
+            for (const a of [...(n?.ancestors ?? [])].reverse()) {
+                if (routeTot.has(a))
+                    return a;
+            }
+            return null;
+        };
+        for (const g of echt.values()) {
+            const kind = g.status === "mislukt" ? "stuck" : g.status === "wachtend" || g.status === "waarschuwing" ? "busy" : "done";
+            const uitleg = vakUitleg(g);
+            const verouderd = onbereikbaar.has(g.nodeId);
+            const doel = verouderd ? vervangend(g.nodeId) : g.nodeId;
+            if (!doel)
+                continue;
+            const bestaand = markers.get(doel);
+            const marker = {
+                kind: bestaand && bestaand.kind === "stuck" ? bestaand.kind : kind,
+                text: uitleg.beslissing,
+                beslissing: uitleg.beslissing,
+                waarom: uitleg.waarom,
+                feiten: uitleg.feiten,
+                at: g.laatste,
+                durationMs: g.duurMs,
+                count: (bestaand?.count ?? 0) + g.aantal,
+                attempts: Math.max(bestaand?.attempts ?? 0, g.pogingen),
+                errorClass: g.errorClass ?? bestaand?.errorClass ?? null,
+                nextStep: g.volgendeStap,
+                verouderd: verouderd || bestaand?.verouderd === true,
+            };
+            markers.set(doel, marker);
+        }
+        // Een lopende stap waar de route stopt is een stoppunt met eigen uitleg.
+        for (const id of lopend) {
+            if (!routeTot.has(id) || doorgelaten.has(id))
+                continue;
+            const bestaand = markers.get(id);
+            markers.set(id, {
+                kind: bestaand?.kind ?? "busy",
+                text: bestaand?.text ?? "Deze stap loopt nog",
+                ...bestaand,
+                eindpunt: true,
+                stop: bestaand?.stop ??
+                    stopReden({
+                        nodeId: id,
+                        groep: echt.get(id) ?? null,
+                        stand: stand ?? null,
+                        verouderd: bestaand?.verouderd === true,
+                    }),
+            });
+        }
+        markeerEindpunt(markers, routeTot, routeEdgeLijst.map((e) => ({ from: e.from, to: e.to })), byId, echt, stand ?? null);
+        return {
+            // Een geselecteerde order kleurt alleen de gelopen route. De volledige
+            // flowchart blijft zichtbaar, ook na een fout of definitief stoppunt.
+            tree: { nodes: newNodes, edges: newEdges },
+            markers,
+            wachtpunten,
+        };
+    }
+    /** Ligt dit vakje op de reis volgens de heuristiek? */
     const opReis = (n) => {
         if (bronTak(n.id) || n.id === FLOW_NODE.samenvoegen) {
-            return bronOk(n.id) && (echt ? true : bereikt(-1));
-        }
-        if (echt) {
-            if (echt.has(n.id))
-                return true;
-            if (n.ancestors.some((a) => echt.has(a)))
-                return true;
-            if (n.stepId && echt.has(`stap:${n.stepId}`))
-                return true;
-            if (n.id === "__start" || n.id === "__bron" || n.id === "__bron_merge")
-                return true;
-            return false;
+            return bronOk(n.id) && bereikt(-1);
         }
         return bereikt(stapIndex(n, byId));
     };
-    const demote = (s) => (s === "active" ? "possible" : s);
     const newNodes = nodes.map((n) => {
         const ok = n.state === "active" && opReis(n);
         return ok ? { ...n, route: true } : { ...n, state: demote(n.state), route: false };
@@ -243,38 +561,23 @@ export function applyRoute(tree, route, groepen) {
         const from = byId.get(e.from);
         const ok = nodeState.get(e.from) === "active" &&
             nodeState.get(e.to) === "active" &&
-            (echt
-                ? !!(from && to && opReis(from) && opReis(to))
-                : bereikt(Math.max(stapIndex(from, byId), stapIndex(to, byId)))) &&
+            bereikt(Math.max(stapIndex(from, byId), stapIndex(to, byId))) &&
             bronOk(e.from) &&
             bronOk(e.to);
         return ok ? { ...e, route: true } : { ...e, state: "possible", route: false };
     });
-    if (echt) {
-        for (const g of echt.values()) {
-            const kind = g.status === "mislukt" ? "stuck" : g.status === "wachtend" || g.status === "waarschuwing" ? "busy" : "done";
-            const uitleg = vakUitleg(g);
-            markers.set(g.nodeId, {
-                kind,
-                text: uitleg.beslissing,
-                beslissing: uitleg.beslissing,
-                waarom: uitleg.waarom,
-                feiten: uitleg.feiten,
-                at: g.laatste,
-                durationMs: g.duurMs,
-                count: g.aantal,
-                attempts: g.pogingen,
-                errorClass: g.errorClass,
-                nextStep: g.volgendeStap,
-            });
-        }
-        return { tree: { nodes: newNodes, edges: newEdges }, markers };
-    }
     if (route.stuck)
         markers.set(`stap:${route.stuck.stepId}`, { kind: "stuck", text: route.stuck.reason });
     else if (route.busy)
         markers.set(`stap:${route.busy.stepId}`, { kind: "busy", text: route.busy.reason });
     if (route.finished)
         markers.set("__eind", { kind: "done", text: "Afgehandeld" });
-    return { tree: { nodes: newNodes, edges: newEdges }, markers };
+    const heuristischeRoute = new Set(newNodes.filter((n) => n.route).map((n) => n.id));
+    markeerEindpunt(markers, heuristischeRoute, newEdges.filter((e) => e.route).map((e) => ({ from: e.from, to: e.to })), byId, null, stand ?? null);
+    return {
+        // Ook oudere orders houden de volledige grijze vervolgstructuur in beeld.
+        tree: { nodes: newNodes, edges: newEdges },
+        markers,
+        wachtpunten: new Set(),
+    };
 }

package/dist-lib/lib/flowTree.d.ts

@@ -30,9 +30,21 @@ export interface TreeNode {
     fieldKeys?: string[];
     /** Ligt op de gelopen route van een gekozen order (blauwe lijn). */
     route?: boolean;
+    /** Alleen bij samenkomstpunten: wanneer mag de flow hier verder? */
+    wacht?: MergeWacht;
     w: number;
     h: number;
 }
+/** Wanneer een samenkomstpunt de flow doorlaat. */
+export interface MergeWacht {
+    wanneer: "een" | "alle" | "specifiek";
+    /** Alleen bij "specifiek": de id van de verplichte binnenkomende lijn. */
+    verplichteLijn: string | null;
+    /** Vangnet: na zoveel minuten gaat de flow alsnog verder. */
+    maxWachtMinuten: number;
+    /** Korte tekst voor op de kaart ("alle", "één", naam van de lijn). */
+    label: string;
+}
 export interface TreeEdge {
     id: string;
     from: string;
@@ -60,5 +72,78 @@ export declare const NODE_SIZE: Record<TreeNodeKind, {
 export declare function fieldsFor(storeId?: string, keys?: string[]): RuleField[];
 export declare function valueText(field: RuleField, value: unknown): string;
 /** Bouwt de complete beslisboom van binnenkomst tot afgehandelde order. */
-export declare function buildFlowTree(settings: RuleEngineSettings): FlowTree;
+export declare function buildFlowTree(settings: RuleEngineSettings, overrides?: MergeOverrides): FlowTree;
+/** Handmatige keuzes per ruitje, bewaard bij de werkwijze. */
+export interface MergeOverride {
+    /** Ruitje weggehaald: de lijnen worden rechtstreeks doorgetrokken. */
+    verwijderd?: boolean;
+    /** Per binnenkomende lijn: mag een order hier doorlopen? */
+    lijnen?: Record<string, "door" | "stop">;
+    /** Wanneer mag de flow hier verder? Standaard: zodra één lijn klaar is. */
+    wanneer?: "een" | "alle" | "specifiek";
+    /** Alleen bij "specifiek": id van de verplichte binnenkomende lijn. */
+    verplichteLijn?: string;
+    /** Vangnet tegen eeuwig wachten, in minuten. */
+    maxWachtMinuten?: number;
+}
+export type MergeOverrides = Record<string, MergeOverride>;
+/** Standaard vangnet: na een half uur gaat de flow alsnog verder. */
+export declare const MERGE_MAX_WACHT_MINUTEN = 30;
+/** Eén binnenkomende lijn van een samenkomstpunt, zoals het paneel die toont. */
+export interface MergeLijn {
+    id: string;
+    from: string;
+    naam: string;
+    /** Telt mee voor de voorwaarde (niet uitgeschakeld en niet op "stopt hier"). */
+    telt: boolean;
+}
+/**
+ * De voorwaarde van één samenkomstpunt, met de lijnen die meetellen.
+ * Lijnen die volgens de huidige werkwijze uitgeschakeld zijn of op "Stopt hier"
+ * staan tellen nooit mee: een tak die nooit gelopen kan worden mag de flow niet
+ * tegenhouden.
+ */
+export declare function mergeVoorwaarde(tree: FlowTree, mergeId: string, override: MergeOverride | undefined): {
+    wanneer: "een" | "alle" | "specifiek";
+    lijnen: MergeLijn[];
+    verplichteLijn: string | null;
+    maxWachtMinuten: number;
+    /** De gekozen verplichte lijn bestaat niet meer: teruggevallen op "één". */
+    terugval: boolean;
+    /**
+     * De meetellende lijnen sluiten elkaar uit (verschillende herkomsten, of
+     * takken van dezelfde keuze): een order komt maar via één binnen, dus "alle
+     * flows" kan hier nooit gehaald worden en is niet in te stellen.
+     */
+    uitsluitend: boolean;
+    label: string;
+};
+/**
+ * Overbodige ruitjes wegrekenen: een ruitje met één lijn erin en één lijn eruit
+ * voegt niets toe, en een ruitje waar niets meer op uitkomt hoort er niet te
+ * staan. De vaste verzamelpunten per stap blijven altijd staan.
+ */
+export declare function vereenvoudigMerges(tree: FlowTree, behoud?: Set<string>): FlowTree;
+/** Handmatige keuzes van de gebruiker op de ruitjes toepassen. */
+export declare function pasMergeOverridesToe(tree: FlowTree, overrides: MergeOverrides | undefined): FlowTree;
+/**
+ * Zonder geselecteerde order: vakjes waar de route ophoudt krijgen geen
+ * doorlopende lijnen meer.
+ *
+ * Eindstation is:
+ *  - een vakje waarvan élk vervolg uitgeschakeld is, en
+ *  - een uitkomst-tegel (`option`): daar hangt per definitie niets meer onder.
+ *
+ * Het samenkomstpunt van een beslissing waar daarna niets meer op uitkomt,
+ * verdwijnt mee. De doorgaande route tussen de stappen blijft altijd heel.
+ */
+export declare function verbergEindnodeLijnen(tree: FlowTree): FlowTree;
+/**
+ * Het vakje "Verzendbrief" per herkomst juist tonen.
+ *
+ * Bij een Floriday-order geldt uitsluitend het officiele Floriday-document;
+ * de regel over de eigen layout hoort daar niet te staan. Alleen tekst: de
+ * kaartstructuur, instellingen en route blijven ongewijzigd.
+ */
+export declare function verduidelijkVerzendbrief(tree: FlowTree, source: "floriday" | "mail" | "actiemail" | "handmatig" | null): FlowTree;
 //# sourceMappingURL=flowTree.d.ts.map

package/dist-lib/lib/flowTree.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"flowTree.d.ts","sourceRoot":"","sources":["../../src/lib/flowTree.ts"],"names":[],"mappings":"AAWA,OAAO,EAIL,KAAK,kBAAkB,EACvB,KAAK,SAAS,EAEf,MAAM,oBAAoB,CAAC;AAG5B,MAAM,MAAM,SAAS,GAAG,QAAQ,GAAG,UAAU,GAAG,UAAU,CAAC;AAE3D,MAAM,MAAM,YAAY,GACpB,OAAO,GACP,KAAK,GACL,QAAQ,GACR,MAAM,GACN,UAAU,GACV,SAAS,GACT,QAAQ,GACR,OAAO,CAAC;AAEZ,MAAM,WAAW,UAAU;IACzB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,QAAQ;IACvB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,YAAY,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,SAAS,CAAC;IACjB,iEAAiE;IACjE,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,4CAA4C;IAC5C,OAAO,CAAC,EAAE,UAAU,EAAE,CAAC;IACvB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,wEAAwE;IACxE,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,iEAAiE;IACjE,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,gEAAgE;IAChE,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IACjB,wEAAwE;IACxE,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB,oEAAoE;IACpE,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX;AAED,MAAM,WAAW,QAAQ;IACvB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,SAAS,CAAC;IACjB,4EAA4E;IAC5E,IAAI,EAAE,MAAM,GAAG,KAAK,CAAC;IACrB,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,oEAAoE;IACpE,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED,MAAM,WAAW,QAAQ;IACvB,KAAK,EAAE,QAAQ,EAAE,CAAC;IAClB,KAAK,EAAE,QAAQ,EAAE,CAAC;CACnB;AAED,eAAO,MAAM,SAAS,EAAE,MAAM,CAAC,YAAY,EAAE;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,CASpE,CAAC;AAwCF;;;GAGG;AACH,wBAAgB,SAAS,CAAC,OAAO,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,EAAE,GAAG,SAAS,EAAE,CAcxE;AAED,wBAAgB,SAAS,CAAC,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,OAAO,GAAG,MAAM,CA0BlE;AA6BD,2EAA2E;AAC3E,wBAAgB,aAAa,CAAC,QAAQ,EAAE,kBAAkB,GAAG,QAAQ,CA+NpE"}
+{"version":3,"file":"flowTree.d.ts","sourceRoot":"","sources":["../../src/lib/flowTree.ts"],"names":[],"mappings":"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"}