@flowselections/floriday-voorraad 1.0.158 → 1.0.164

package/dist-lib/lib/__tests__/article-code.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=article-code.test.d.ts.map

package/dist-lib/lib/__tests__/article-code.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"article-code.test.d.ts","sourceRoot":"","sources":["../../../src/lib/__tests__/article-code.test.ts"],"names":[],"mappings":""}

package/dist-lib/lib/__tests__/article-code.test.js

@@ -0,0 +1,11 @@
+import { describe, it, expect } from "vitest";
+import { articleCodeProblem } from "../article-code.js";
+describe("artikelcode-controle", () => {
+    it("weigert Artikelcode", () => expect(articleCodeProblem("Artikelcode", "Strelitzia")).not.toBeNull());
+    it("weigert Naam", () => expect(articleCodeProblem(" naam ", "X")).not.toBeNull());
+    it("weigert test", () => expect(articleCodeProblem("TEST", "X")).not.toBeNull());
+    it("weigert leeg", () => expect(articleCodeProblem("  ", "X")).not.toBeNull());
+    it("staat TQA2710G toe", () => expect(articleCodeProblem("TQA2710G", "Gaultheria")).toBeNull());
+    it("weigert code gelijk aan naam bij handmatig", () => expect(articleCodeProblem("Strelitzia", "strelitzia", "manual")).not.toBeNull());
+    it("staat code gelijk aan naam toe bij import", () => expect(articleCodeProblem("Strelitzia", "strelitzia", "import")).toBeNull());
+});

package/dist-lib/lib/__tests__/erp-test-123.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=erp-test-123.test.d.ts.map

package/dist-lib/lib/__tests__/erp-test-123.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"erp-test-123.test.d.ts","sourceRoot":"","sources":["../../../src/lib/__tests__/erp-test-123.test.ts"],"names":[],"mappings":""}

package/dist-lib/lib/__tests__/erp-test-123.test.js

@@ -0,0 +1,43 @@
+import { describe, expect, it } from "vitest";
+import { resolveBuyerOrganizations, isMissingFunctionError } from "../buyer-organizations.js";
+import { missingPackingFields, simplePackingToRow, engineOordeelRegel, ENGINE_CARRIER_CODE } from "../simple-packing.js";
+const cache = async () => ["cache-1"];
+describe("kopers: vaste zoekvolgorde", () => {
+    it("expliciete keuze gaat voor alles", async () => {
+        const r = await resolveBuyerOrganizations({ explicit: ["a"], priceGroupCustomers: ["b"], authFunction: ["c"], connectionsCache: cache });
+        expect(r).toMatchObject({ ids: ["a"], source: "keuze" });
+    });
+    it("zonder keuze: klanten van de prijsgroep", async () => {
+        const r = await resolveBuyerOrganizations({ explicit: [], priceGroupCustomers: ["b", "b", "b2"], authFunction: ["c"], connectionsCache: cache });
+        expect(r).toMatchObject({ ids: ["b", "b2"], source: "prijsgroep" });
+    });
+    it("daarna floriday_buyer_organizations, ook als die leeg is (geen terugval op de oude cache)", async () => {
+        const r = await resolveBuyerOrganizations({ explicit: [], priceGroupCustomers: [], authFunction: [], connectionsCache: cache });
+        expect(r.source).toBe("geen");
+        expect(r.ids).toEqual([]);
+    });
+    it("alleen als de functie nog niet bestaat: de oude koppelingscache", async () => {
+        const r = await resolveBuyerOrganizations({ explicit: [], priceGroupCustomers: [], authFunction: null, connectionsCache: cache });
+        expect(r).toMatchObject({ ids: ["cache-1"], source: "floriday_connections_cache" });
+    });
+    it("herkent een ontbrekende functie", () => {
+        expect(isMissingFunctionError({ code: "PGRST202" })).toBe(true);
+        expect(isMissingFunctionError({ code: "42501", message: "geen toegang" })).toBe(false);
+    });
+});
+describe("belading in de eenvoudige route", () => {
+    const full = { vbnPackageCode: "412", piecesPerPackage: "12", packagesPerLayer: "5", layersPerLoadCarrier: "8", loadCarrier: "DANISH_TROLLEY" };
+    it("alle vijf velden verplicht, ook lagen per kar en ladingdrager", () => {
+        expect(missingPackingFields({ ...full, layersPerLoadCarrier: "" })).toEqual(["lagen per kar"]);
+        expect(missingPackingFields({ ...full, loadCarrier: "" })).toEqual(["ladingdrager"]);
+        expect(missingPackingFields(full)).toEqual([]);
+    });
+    it("geen standaardwaarden: onvolledig = fout", () => {
+        expect(() => simplePackingToRow({ ...full, piecesPerPackage: "0" })).toThrow(/planten per fust/);
+    });
+    it("Deense container (DC) gaat als danish_container naar de Engine", () => {
+        expect(ENGINE_CARRIER_CODE.DANISH_TROLLEY).toBe("danish_container");
+        expect(engineOordeelRegel("p1", full)).toEqual({ product_id: "p1", carrier_code: "danish_container", plants_per_crate: 12, crates_per_layer: 5, layers_per_cart: 8 });
+        expect(simplePackingToRow(full)).toMatchObject({ vbn_package_code: 412, pieces_per_package: 12, packages_per_layer: 5, layers_per_load_carrier: 8, is_primary: true });
+    });
+});

package/dist-lib/lib/__tests__/floricode-required-features.test.js

@@ -155,7 +155,8 @@ describe("computeVbnRequiredFeatures — VBN 100023", () => {
     });
     it("sorteert verplicht vóór advies", async () => {
         const res = await computeVbnRequiredFeatures(client, "100023");
-        expect(res.features.map((f) => f.code)).toEqual(["S01", "S02", "S05"]);
+        // S62 en S98 eist Floriday altijd (FORCED_REQUIRED), dus ook verplicht.
+        expect(res.features.map((f) => f.code)).toEqual(["S01", "S02", "S62", "S98", "S05"]);
     });
     it("levert toegestane waarden per feature (gededupliceerd, zonder vervallen)", async () => {
         const res = await computeVbnRequiredFeatures(client, "100023");
@@ -163,9 +164,10 @@ describe("computeVbnRequiredFeatures — VBN 100023", () => {
         expect(s01?.values.map((v) => v.code).sort()).toEqual(["003", "004"]);
         expect(s01?.values.some((v) => v.code === "999")).toBe(false);
     });
-    it("geeft lege lijst terug voor onbekende VBN-code", async () => {
+    it("geeft alleen de door Floriday altijd verplichte kenmerken voor onbekende VBN-code", async () => {
         const res = await computeVbnRequiredFeatures(client, "99999");
-        expect(res).toEqual({ vbnCode: "99999", features: [] });
+        expect(res.vbnCode).toBe("99999");
+        expect(res.features.map((f) => f.code)).toEqual(["S62", "S98"]);
     });
     it("vindt regulatory rows via record_id-prefix als data.product_id ontbreekt", async () => {
         const prefixOnlyClient = makeFakeClient({
@@ -180,6 +182,8 @@ describe("computeVbnRequiredFeatures — VBN 100023", () => {
         expect(res.features.map((f) => [f.code, f.regulation])).toEqual([
             ["S01", "required"],
             ["S02", "required"],
+            ["S62", "required"],
+            ["S98", "required"],
             ["S05", "advised"],
         ]);
     });

package/dist-lib/lib/__tests__/floriday-customer-offers.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=floriday-customer-offers.test.d.ts.map

package/dist-lib/lib/__tests__/floriday-customer-offers.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"floriday-customer-offers.test.d.ts","sourceRoot":"","sources":["../../../src/lib/__tests__/floriday-customer-offers.test.ts"],"names":[],"mappings":""}

package/dist-lib/lib/__tests__/floriday-customer-offers.test.js

@@ -0,0 +1,36 @@
+import { describe, expect, it } from "vitest";
+import { customerOffersByTradeItem } from "../floriday-customer-offers.js";
+const NOW = new Date("2026-10-20T10:00:00Z");
+const TID = "AAAAAAAA-1111-2222-3333-444444444444";
+const line = (over = {}) => ({
+    tradeItemId: TID,
+    pricePerPiece: { value: 0.85, currency: "EUR" },
+    numberOfPieces: 500,
+    tradePeriod: { startDateTime: "2026-10-01T00:00:00Z", endDateTime: "2026-11-01T00:00:00Z" },
+    isDeleted: false,
+    ...over,
+});
+const offer = (over = {}, lines = [line()]) => ({
+    floriday_id: "o1",
+    data: { customerOfferId: "o1", customerOfferType: "SUPPLY_REQUEST", isDraft: false, isDeleted: false,
+        customerOrganizationId: "CUST-1", customerOfferLines: lines, ...over },
+});
+describe("klantaanbiedingen koppelen op customerOfferLines[].tradeItemId", () => {
+    it("koppelt een actuele regel op artikel-id, met klantnaam", () => {
+        const m = customerOffersByTradeItem([offer()], new Map([["cust-1", "Plantor"]]), NOW);
+        const v = m.get(TID.toLowerCase());
+        expect(v).toHaveLength(1);
+        expect(v[0].price).toBe(0.85);
+        expect(v[0].pieces).toBe(500);
+        expect(v[0].customer).toBe("Plantor");
+    });
+    it("slaat verlopen regels over", () => {
+        const m = customerOffersByTradeItem([offer({}, [line({ tradePeriod: { endDateTime: "2024-12-28T00:00:00Z" } })])], new Map(), NOW);
+        expect(m.size).toBe(0);
+    });
+    it("slaat concepten, verwijderde aanbiedingen en verwijderde regels over", () => {
+        expect(customerOffersByTradeItem([offer({ isDraft: true })], new Map(), NOW).size).toBe(0);
+        expect(customerOffersByTradeItem([offer({ isDeleted: true })], new Map(), NOW).size).toBe(0);
+        expect(customerOffersByTradeItem([offer({}, [line({ isDeleted: true })])], new Map(), NOW).size).toBe(0);
+    });
+});

package/dist-lib/lib/__tests__/floriday-fetch-status.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=floriday-fetch-status.test.d.ts.map

package/dist-lib/lib/__tests__/floriday-fetch-status.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"floriday-fetch-status.test.d.ts","sourceRoot":"","sources":["../../../src/lib/__tests__/floriday-fetch-status.test.ts"],"names":[],"mappings":""}

package/dist-lib/lib/__tests__/floriday-fetch-status.test.js

@@ -0,0 +1,25 @@
+import { describe, expect, it } from "vitest";
+import { fetchState, fetchStateBlocksTakeover } from "../floriday-fetch-status.js";
+const row = (t, done, ok) => ({
+    backfill_target_sequence: t, backfill_done_at: done, last_success_at: ok,
+});
+describe("ophaalstatus artikelen", () => {
+    it("lopend ophalen blokkeert overnemen", () => {
+        expect(fetchState(row(500, null, "2026-10-20"), 120)).toBe("bezig");
+        expect(fetchStateBlocksTakeover(fetchState(row(500, null, null), 0))).toBe(true);
+    });
+    it("nog nooit gestart blokkeert overnemen", () => {
+        expect(fetchState(null, 0)).toBe("nooit_gestart");
+        expect(fetchState(row(null, null, null), 0)).toBe("nooit_gestart");
+        expect(fetchStateBlocksTakeover("nooit_gestart")).toBe(true);
+    });
+    it("na afloop met lege target komt de knop vrij", () => {
+        expect(fetchState(row(null, "2026-10-20", "2026-10-20"), 50)).toBe("compleet");
+        expect(fetchState(row(500, "2026-10-20", "2026-10-20"), 50)).toBe("compleet");
+        expect(fetchStateBlocksTakeover(fetchState(row(null, null, "2026-10-20"), 0))).toBe(false);
+    });
+    it("koppeling van vóór 1.0.95 zonder backfill is compleet", () => {
+        expect(fetchState(row(null, null, "2026-09-01"), 300)).toBe("compleet");
+        expect(fetchState(null, 300)).toBe("compleet");
+    });
+});

package/dist-lib/lib/__tests__/floriday-write-mode.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=floriday-write-mode.test.d.ts.map

package/dist-lib/lib/__tests__/floriday-write-mode.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"floriday-write-mode.test.d.ts","sourceRoot":"","sources":["../../../src/lib/__tests__/floriday-write-mode.test.ts"],"names":[],"mappings":""}

package/dist-lib/lib/__tests__/floriday-write-mode.test.js

@@ -0,0 +1,40 @@
+import { describe, expect, it } from "vitest";
+import { gateBlockedText, waitCauseText, WRITE_MODE_UNREADABLE_TEXT } from "../floriday-write-mode.js";
+import { resolveFustDimensions } from "../fusten.js";
+import { loadCarriersFromCache } from "../../components/voorraad/FloridayLoadCarriers.js";
+describe("oorzaak bij wachtende regels", () => {
+    it("toont reason als read_only aan staat", () => {
+        expect(waitCauseText({ read_only: true, reason: "Alleen lezen staat aan" })).toBe("Alleen lezen staat aan");
+    });
+    it("toont niets als schrijven aan staat", () => {
+        expect(waitCauseText({ read_only: false, reason: null })).toBeNull();
+    });
+    it("meldt onbekend als lezen mislukt", () => {
+        expect(waitCauseText(null)).toBe(WRITE_MODE_UNREADABLE_TEXT);
+    });
+    it("verpakkingsverschil noemt artikel en verwijst naar Verpakking", () => {
+        const t = gateBlockedText({ name: "Roos", code: "R1" });
+        expect(t).toContain("Roos (R1)");
+        expect(t).toContain("Floriday koppeling → Verpakking");
+    });
+});
+describe("fustmaten zonder standaardwaarden", () => {
+    const fc = new Map([["12", { name: "Deksel", lengthMm: 1000, widthMm: 300, heightMm: null }]]);
+    it("Floricode gaat voor, lege maat blijft leeg", () => {
+        expect(resolveFustDimensions({ vbn_code: 12, length_mm: null, width_mm: null, height_mm: null }, fc))
+            .toEqual({ length_mm: 1000, width_mm: 300, height_mm: null, source: "floricode" });
+    });
+    it("onbekend fust krijgt geen maten", () => {
+        expect(resolveFustDimensions({ vbn_code: 99, length_mm: null, width_mm: null, height_mm: null }, fc))
+            .toEqual({ length_mm: null, width_mm: null, height_mm: null, source: "onbekend" });
+    });
+    it("handmatige maat blijft staan", () => {
+        expect(resolveFustDimensions({ vbn_code: 99, length_mm: 500, width_mm: null, height_mm: null }, fc).source).toBe("handmatig");
+    });
+});
+describe("ladingdrager uit de Floriday-gegevens", () => {
+    it("leest loadCarrier per verpakking, leeg blijft leeg", () => {
+        expect(loadCarriersFromCache({ packingConfigurations: [{ loadCarrier: "DANISH_TROLLEY", primary: true }, {}] }))
+            .toEqual([{ loadCarrier: "DANISH_TROLLEY", primary: true }, { loadCarrier: null, primary: false }]);
+    });
+});

package/dist-lib/lib/__tests__/fust-dimensions.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=fust-dimensions.test.d.ts.map

package/dist-lib/lib/__tests__/fust-dimensions.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fust-dimensions.test.d.ts","sourceRoot":"","sources":["../../../src/lib/__tests__/fust-dimensions.test.ts"],"names":[],"mappings":""}

package/dist-lib/lib/__tests__/fust-dimensions.test.js

@@ -0,0 +1,27 @@
+import { describe, expect, it, vi } from "vitest";
+vi.mock("../../integrations/supabase/client", () => ({ supabase: {} }));
+import { customPackageDimsOf, resolveFustDimensions } from "../fusten.js";
+const fc = new Map([["18", { name: "Trayrand", lengthMm: 560, widthMm: 250, heightMm: 170 }]]);
+const cp = new Map([["cp-1", { lengthMm: 400, widthMm: 300, heightMm: 120 }]]);
+const base = { vbn_code: null, custom_package_id: null, length_mm: null, width_mm: null, height_mm: null };
+describe("fustmaten: Floricode → Floriday custom package → handmatig → leeg", () => {
+    it("Floricode wint", () => {
+        const r = resolveFustDimensions({ ...base, vbn_code: 18, custom_package_id: "cp-1", length_mm: 1 }, fc, cp);
+        expect(r).toEqual({ length_mm: 560, width_mm: 250, height_mm: 170, source: "floricode" });
+    });
+    it("anders custom package", () => {
+        const r = resolveFustDimensions({ ...base, custom_package_id: "cp-1", length_mm: 1 }, fc, cp);
+        expect(r).toEqual({ length_mm: 400, width_mm: 300, height_mm: 120, source: "floriday" });
+    });
+    it("anders handmatig", () => {
+        const r = resolveFustDimensions({ ...base, custom_package_id: "onbekend", length_mm: 7 }, fc, cp);
+        expect(r.source).toBe("handmatig");
+        expect(r.length_mm).toBe(7);
+    });
+    it("anders leeg, nooit standaardwaarden", () => {
+        expect(resolveFustDimensions(base, fc, cp)).toEqual({ length_mm: null, width_mm: null, height_mm: null, source: "onbekend" });
+    });
+    it("leest mm uit data.dimensions", () => {
+        expect(customPackageDimsOf({ dimensions: { length: 400, width: 0, height: "120" } })).toEqual({ lengthMm: 400, widthMm: null, heightMm: 120 });
+    });
+});

package/dist-lib/lib/__tests__/load-carriers.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=load-carriers.test.d.ts.map

package/dist-lib/lib/__tests__/load-carriers.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"load-carriers.test.d.ts","sourceRoot":"","sources":["../../../src/lib/__tests__/load-carriers.test.ts"],"names":[],"mappings":""}

package/dist-lib/lib/__tests__/load-carriers.test.js

@@ -0,0 +1,15 @@
+import { describe, it, expect, vi } from "vitest";
+vi.mock("../../integrations/supabase/client", () => ({ supabase: {} }));
+import { loadCarriersFromRows } from "../../hooks/useLoadCarriers.js";
+describe("gedeelde lijst ladingdragers", () => {
+    it("neemt codes en namen over uit de database, op volgorde", () => {
+        const list = loadCarriersFromRows([
+            { code: "DANISH_TROLLEY", naam: "Deense container", volgorde: 2 },
+            { code: "AUCTION_TROLLEY", naam: "Stapelwagen", volgorde: 1 },
+        ]);
+        expect(list.map((c) => c.code)).toEqual(["AUCTION_TROLLEY", "DANISH_TROLLEY"]);
+    });
+    it("vult niets zelf aan als de database niets geeft", () => {
+        expect(loadCarriersFromRows(null)).toEqual([]);
+    });
+});

package/dist-lib/lib/__tests__/mirror-products.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=mirror-products.test.d.ts.map

package/dist-lib/lib/__tests__/mirror-products.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mirror-products.test.d.ts","sourceRoot":"","sources":["../../../src/lib/__tests__/mirror-products.test.ts"],"names":[],"mappings":""}

package/dist-lib/lib/__tests__/mirror-products.test.js

@@ -0,0 +1,13 @@
+import { describe, expect, it } from "vitest";
+import { hideMirrorItems } from "../mirror-products.js";
+describe("hideMirrorItems", () => {
+    it("verbergt een spiegel (id = Floriday-id van eigen artikel), ook met voorraad", () => {
+        const own = { productId: "27612767", floridayId: "ea7776dd", qty: 450 };
+        const mirror = { productId: "ea7776dd", floridayId: null, qty: 500 };
+        expect(hideMirrorItems([own, mirror])).toEqual([own]);
+    });
+    it("laat een spiegel staan zolang er geen canoniek artikel is", () => {
+        const mirror = { productId: "ea7776dd", floridayId: null };
+        expect(hideMirrorItems([mirror])).toEqual([mirror]);
+    });
+});

package/dist-lib/lib/__tests__/product-packings.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=product-packings.test.d.ts.map

package/dist-lib/lib/__tests__/product-packings.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"product-packings.test.d.ts","sourceRoot":"","sources":["../../../src/lib/__tests__/product-packings.test.ts"],"names":[],"mappings":""}

package/dist-lib/lib/__tests__/product-packings.test.js

@@ -0,0 +1,42 @@
+import { describe, expect, it, vi } from "vitest";
+vi.mock("../../integrations/supabase/client", () => ({ supabase: {} }));
+import { requireCompletePacking, packingNumberOrEmpty } from "../floriday-payload.js";
+import { isCompletePackingRow, packingRowsFromWizard, positiveIntOrNull, primaryPacking } from "../product-packings.js";
+import { floridayPackingsToRows, pickPrimaryPacking } from "../product-packing.js";
+describe("verpakking: geen stille standaardwaarden", () => {
+    it("lege of ongeldige getallen blijven leeg", () => {
+        expect(positiveIntOrNull("")).toBeNull();
+        expect(positiveIntOrNull(undefined)).toBeNull();
+        expect(positiveIntOrNull(0)).toBeNull();
+        expect(positiveIntOrNull(2.5)).toBeNull();
+        expect(packingNumberOrEmpty(undefined)).toBe(0);
+    });
+    it("push weigert een onvolledige verpakking", () => {
+        expect(() => requireCompletePacking({ unitsPerPackage: 6, packagesPerLayer: 4 })).toThrow(/Verpakking onvolledig/);
+        expect(requireCompletePacking({ unitsPerPackage: 6, packagesPerLayer: 4, layersPerLoadCarrier: 8 })).toEqual({
+            pieces: 6, packages: 4, layers: 8,
+        });
+    });
+    it("Floriday-verpakking 8x4x6 (fust 306) wordt exact overgenomen", () => {
+        const rows = floridayPackingsToRows([
+            { primary: true, piecesPerPackage: 6, packagesPerLayer: 4, layersPerLoadCarrier: 8, package: { vbnPackageCode: 306 }, loadCarrier: "DANISH_TROLLEY" },
+            { primary: false, piecesPerPackage: 8, packagesPerLayer: 5, package: { vbnPackageCode: 408 } },
+        ]);
+        expect(rows[0]).toMatchObject({ pieces_per_package: 6, packages_per_layer: 4, layers_per_load_carrier: 8, vbn_package_code: 306, is_primary: true });
+        expect(rows[1]).toMatchObject({ layers_per_load_carrier: null, is_primary: false });
+    });
+    it("zonder gemarkeerde primaire verpakking wordt niet gegokt", () => {
+        expect(pickPrimaryPacking([{ piecesPerPackage: 6, packagesPerLayer: 4, layersPerLoadCarrier: 8 }])).toBeNull();
+    });
+    it("meerdere verpakkingen: de primaire bepaalt", () => {
+        const rows = packingRowsFromWizard([
+            { id: "a", source: "VBN", packagingType: "306", loadCarrier: "", unitsPerPackage: 6, packagesPerLayer: 4, layersPerLoadCarrier: 8, isPrimary: false, isCustomerSpecific: false, customerOrganizationIds: [] },
+            { id: "b", source: "VBN", packagingType: "408", loadCarrier: "", unitsPerPackage: 8, packagesPerLayer: 5, layersPerLoadCarrier: 8, isPrimary: true, isCustomerSpecific: false, customerOrganizationIds: [] },
+        ]);
+        const p = primaryPacking(rows);
+        expect(p?.pieces_per_package).toBe(8);
+        expect(p?.vbn_package_code).toBe(408);
+        expect(isCompletePackingRow(p)).toBe(true);
+        expect(isCompletePackingRow({ ...p, layers_per_load_carrier: null })).toBe(false);
+    });
+});

package/dist-lib/lib/__tests__/publish-114.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=publish-114.test.d.ts.map

package/dist-lib/lib/__tests__/publish-114.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"publish-114.test.d.ts","sourceRoot":"","sources":["../../../src/lib/__tests__/publish-114.test.ts"],"names":[],"mappings":""}

package/dist-lib/lib/__tests__/publish-114.test.js

@@ -0,0 +1,31 @@
+import { describe, it, expect } from "vitest";
+import { translatePublishError } from "../publish-errors.js";
+import { effectiveJobStatus } from "../../components/voorraad/PublishProgressCard.js";
+import { countStock } from "../../components/voorraad/VoorraadPage.js";
+describe("1.0.114 publiceren en telling", () => {
+    it("toont de echte reden als de poort schrijven tegenhoudt", () => {
+        const f = translatePublishError(new Error("publishTradeItem: gateway /api/public/gateway/write → Tegengehouden door poort: in de Floriday-kopie wijkt de verpakking af van Floriday."));
+        expect(f.code).toBe("GATE_BLOCKED");
+        expect(f.message).toContain("wijkt de verpakking af");
+    });
+    it("onbekende fout toont de technische reden", () => {
+        const f = translatePublishError(new Error("stap x → iets raars"));
+        expect(f.message).toContain("iets raars");
+    });
+    it("job blijft niet op bezig na mislukte productstap", () => {
+        expect(effectiveJobStatus("running", [
+            { status: "failed", step_key: "trade-item" },
+            { status: "pending", step_key: "stock" },
+        ])).toBe("failed");
+        expect(effectiveJobStatus("running", [{ status: "running", step_key: "trade-item" }])).toBe("running");
+    });
+    it("volledig gereserveerd telt als op voorraad", () => {
+        const c = countStock([
+            { quantity: 100, availableQuantity: 0, minQuantity: 0 },
+            { quantity: 0, availableQuantity: 0, minQuantity: 0 },
+        ]);
+        expect(c.inStock).toBe(1);
+        expect(c.outOfStock).toBe(1);
+        expect(c.fullyReserved).toBe(1);
+    });
+});

package/dist-lib/lib/__tests__/publish-packing-block.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=publish-packing-block.test.d.ts.map

package/dist-lib/lib/__tests__/publish-packing-block.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"publish-packing-block.test.d.ts","sourceRoot":"","sources":["../../../src/lib/__tests__/publish-packing-block.test.ts"],"names":[],"mappings":""}

package/dist-lib/lib/__tests__/publish-packing-block.test.js

@@ -0,0 +1,14 @@
+import { describe, it, expect } from "vitest";
+import { parsePackingBlock } from "../publish-errors.js";
+describe("parsePackingBlock", () => {
+    it("leest code, data.message en mismatchTradeItemIds", () => {
+        const r = parsePackingBlock('fout: {"code":"packing_mismatch","data":{"message":"Afwijking","mismatchTradeItemIds":["a1"]}}');
+        expect(r).toEqual({ code: "packing_mismatch", message: "Afwijking", ids: ["a1"] });
+    });
+    it("onderscheidt packing_mismatch_connection", () => {
+        expect(parsePackingBlock("packing_mismatch_connection")?.code).toBe("packing_mismatch_connection");
+    });
+    it("geeft null zonder code", () => {
+        expect(parsePackingBlock("iets anders")).toBeNull();
+    });
+});

package/dist-lib/lib/__tests__/release-130.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=release-130.test.d.ts.map

package/dist-lib/lib/__tests__/release-130.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"release-130.test.d.ts","sourceRoot":"","sources":["../../../src/lib/__tests__/release-130.test.ts"],"names":[],"mappings":""}

package/dist-lib/lib/__tests__/release-130.test.js

@@ -0,0 +1,103 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { READ_ROUTE_MISSING, chunk, interpretContinuousStock, parseReadResponse, toReadRequest, } from "../floriday-read-contract.js";
+import { editTargetText, isPublishedToFloriday, publishOutcome } from "../publish-status.js";
+import { priceStatus } from "../price-status.js";
+import { validateStep } from "../floriday-payload.js";
+vi.mock("../supabase-admin.server", () => ({
+    getAdminClient: () => ({
+        from: () => ({
+            select: () => ({ eq: () => ({ maybeSingle: async () => ({ data: null }) }) }),
+            upsert: async () => ({ error: null }),
+        }),
+    }),
+}));
+describe("leesroute floriday-get", () => {
+    it("haalt het voorvoegsel /suppliers-api-2026v1 weg en zet de query apart", () => {
+        expect(toReadRequest("/suppliers-api-2026v1/trade-items/abc/continuous-stock")).toEqual({
+            method: "GET",
+            path: "/trade-items/abc/continuous-stock",
+        });
+        expect(toReadRequest("/suppliers-api-2026v1/trade-items/base-supply?year=2026&week=44")).toEqual({
+            method: "GET",
+            path: "/trade-items/base-supply",
+            query: { year: "2026", week: "44" },
+        });
+    });
+    it("bundelt per 10", () => {
+        expect(chunk(Array.from({ length: 23 }, (_, i) => i)).map((c) => c.length)).toEqual([10, 10, 3]);
+    });
+    it("HTML of 404 van de route = leesroute ontbreekt, nooit ruwe HTML", () => {
+        expect(() => parseReadResponse(404, "text/html", "<html>Not found</html>", 1)).toThrow(READ_ROUTE_MISSING);
+    });
+    it("404 per artikel = geen beschikbaarheid; 429 = wachten volgens retryAfterMs", () => {
+        const [a, b, c] = parseReadResponse(200, "application/json", JSON.stringify({
+            ok: true,
+            results: [
+                { ok: false, status: 404, path: "/trade-items/a/continuous-stock", error: "not found" },
+                { ok: false, status: 429, path: "/trade-items/b/continuous-stock", error: "rate", retryAfterMs: 2500 },
+                { ok: true, status: 200, path: "/trade-items/c/continuous-stock", data: { numberOfPieces: 7 } },
+            ],
+        }), 3);
+        expect(interpretContinuousStock(a)).toEqual({ kind: "pieces", pieces: 0 });
+        expect(interpretContinuousStock(b)).toEqual({ kind: "retry", waitMs: 2500 });
+        expect(interpretContinuousStock(c)).toEqual({ kind: "pieces", pieces: 7 });
+    });
+});
+describe("gatewayRead via floriday-get (gemockt, niets naar Floriday)", () => {
+    const realFetch = globalThis.fetch;
+    beforeEach(() => {
+        process.env.FLORIDAY_GATEWAY_URL = "https://shell.test";
+        process.env.FLORIDAY_GATEWAY_SECRET = "test-secret";
+    });
+    afterEach(() => {
+        globalThis.fetch = realFetch;
+    });
+    it("stuurt één GET-verzoek zonder voorvoegsel naar /api/public/gateway/floriday-get", async () => {
+        const calls = [];
+        globalThis.fetch = vi.fn(async (url, init) => {
+            calls.push({ url: String(url), body: JSON.parse(init.body) });
+            return new Response(JSON.stringify({ ok: true, environment: "staging", results: [{ ok: true, status: 200, path: "/trade-items/x", data: { id: "x" } }] }), { status: 200, headers: { "content-type": "application/json" } });
+        });
+        const { gatewayRead } = await import("../floriday-gateway.server.js");
+        const res = await gatewayRead({ environment: "staging", path: "/suppliers-api-2026v1/trade-items/x" });
+        expect(calls[0].url).toBe("https://shell.test/api/public/gateway/floriday-get");
+        expect(calls[0].body.requests).toEqual([{ method: "GET", path: "/trade-items/x" }]);
+        expect(res).toMatchObject({ ok: true, status: 200, data: { id: "x" } });
+    });
+    it("ontbrekende route geeft 'leesroute ontbreekt in de shell'", async () => {
+        globalThis.fetch = vi.fn(async () => new Response("<html>404</html>", { status: 404, headers: { "content-type": "text/html" } }));
+        const { gatewayRead } = await import("../floriday-gateway.server.js");
+        await expect(gatewayRead({ environment: "staging", path: "/trade-items/x" })).rejects.toThrow(/Leesroute ontbreekt in de shell/);
+    });
+});
+describe("publicatiestatus", () => {
+    it("een artikel met een Floriday-id telt als gepubliceerd", () => {
+        expect(isPublishedToFloriday(null, "ea7776dd-cdee-46e3-ab2a-ffd970bd8d7b")).toBe(true);
+        expect(isPublishedToFloriday(null, "")).toBe(false);
+    });
+    it("artikel gelukt + controle mislukt = waarschuwing, niet mislukt", () => {
+        expect(publishOutcome([{ step_key: "trade-item", status: "succeeded" }, { step_key: "verify", status: "failed" }])).toBe("succeeded_with_warnings");
+        expect(publishOutcome([{ step_key: "trade-item", status: "failed" }])).toBe("failed");
+    });
+    it("met Floriday-id gaan wijzigingen naar Floriday, tenzij alleen-lezen (met reden)", () => {
+        expect(editTargetText({ floridayId: "x", writeReadOnly: false }).sendsToFloriday).toBe(true);
+        const blocked = editTargetText({ floridayId: "x", writeReadOnly: true, writeReason: "verpakkingsverschil" });
+        expect(blocked.sendsToFloriday).toBe(false);
+        expect(blocked.text).toContain("verpakkingsverschil");
+    });
+});
+describe("prijsstatus", () => {
+    const now = Date.parse("2026-10-28T12:00:00Z");
+    it("één label per prijsregel", () => {
+        expect(priceStatus(null, now)).toBe("none");
+        expect(priceStatus({ available_quantity: 500, period_end: "2026-11-30T00:00:00Z" }, now)).toBe("live");
+        expect(priceStatus({ available_quantity: 500, period_end: "2026-10-01T00:00:00Z" }, now)).toBe("expired");
+        expect(priceStatus({ available_quantity: 0, period_end: null }, now)).toBe("drained");
+    });
+});
+describe("artikelcode bij Volgende", () => {
+    it("weigert een invultekst al in de artikelstap", () => {
+        const r = validateStep("artikel", { articleCode: "artikelcode", name: "Gaultheria" });
+        expect(r.ok).toBe(false);
+    });
+});

package/dist-lib/lib/__tests__/release-134.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=release-134.test.d.ts.map

package/dist-lib/lib/__tests__/release-134.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"release-134.test.d.ts","sourceRoot":"","sources":["../../../src/lib/__tests__/release-134.test.ts"],"names":[],"mappings":""}

package/dist-lib/lib/__tests__/release-134.test.js

@@ -0,0 +1,50 @@
+import { describe, expect, it } from "vitest";
+import { contentIdempotencyKey } from "../idempotency-key.js";
+import { compareAfterUpdate, verifyDifferenceMessage } from "../publish-verify.js";
+import { publishOutcome } from "../publish-status.js";
+import { translatePublishError } from "../publish-errors.js";
+const id = "ea7776dd-cdee-46e3-ab2a-ffd970bd8d7b";
+describe("1.0.134 idempotentiesleutel per inhoud", () => {
+    it("naam wijzigen geeft een nieuwe sleutel (nieuwe PUT)", async () => {
+        const a = await contentIdempotencyKey("inventory:trade-item:update", id, { tradeItemName: "TEST QA artikel 28-10" });
+        const b = await contentIdempotencyKey("inventory:trade-item:update", id, { tradeItemName: "TEST QA artikel 28-10 gewijzigd" });
+        expect(a).not.toBe(b);
+    });
+    it("dezelfde wijziging nog eens geeft dezelfde sleutel (geen tweede PUT)", async () => {
+        const a = await contentIdempotencyKey("inventory:trade-item:update", id, { tradeItemName: "X", vbnProductCode: 34407 });
+        const b = await contentIdempotencyKey("inventory:trade-item:update", id, { vbnProductCode: 34407, tradeItemName: "X" });
+        expect(a).toBe(b);
+    });
+    it("sleutel bevat geen vaste versie meer", async () => {
+        const k = await contentIdempotencyKey("inventory:trade-item:update", id, {});
+        expect(k).not.toMatch(/:v1$/);
+        expect(k).toMatch(new RegExp(`^inventory:trade-item:update:${id}:[0-9a-f]{64}$`));
+    });
+});
+describe("1.0.134 controle na update", () => {
+    const item = {
+        tradeItemName: "TEST QA artikel 28-10",
+        vbnProductCode: 34407,
+        packingConfigurations: [{ primary: true, piecesPerPackage: 12, packagesPerLayer: 5, layersPerLoadCarrier: 8, package: { vbnPackageCode: 412 }, loadCarrier: "DANISH_TROLLEY" }],
+    };
+    it("naamafwijking is een verschil met beide waarden", () => {
+        const d = compareAfterUpdate({ name: "TEST QA artikel 28-10 gewijzigd", vbnCode: 34407 }, item);
+        expect(d).toHaveLength(1);
+        expect(verifyDifferenceMessage(d)).toContain("«TEST QA artikel 28-10»");
+        expect(verifyDifferenceMessage(d)).toContain("«TEST QA artikel 28-10 gewijzigd»");
+    });
+    it("verpakkingsafwijking telt", () => {
+        const d = compareAfterUpdate({ packing: { piecesPerPackage: 6, packagesPerLayer: 5, layersPerLoadCarrier: 8, vbnPackageCode: 412, loadCarrier: "DANISH_TROLLEY" } }, item);
+        expect(d.map((x) => x.field)).toEqual(["piecesPerPackage"]);
+    });
+    it("gelijk = geen verschil", () => {
+        expect(compareAfterUpdate({ name: "TEST QA artikel 28-10", vbnCode: "34407" }, item)).toEqual([]);
+    });
+    it("afwijking na update = job mislukt", () => {
+        expect(publishOutcome([
+            { step_key: "trade-item", status: "done" },
+            { step_key: "verify", status: "failed", error_code: "VERIFY_MISMATCH" },
+        ])).toBe("failed");
+        expect(translatePublishError(new Error("VERIFY_MISMATCH:Naam wijkt af")).code).toBe("VERIFY_MISMATCH");
+    });
+});

package/dist-lib/lib/__tests__/release-136.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=release-136.test.d.ts.map

package/dist-lib/lib/__tests__/release-136.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"release-136.test.d.ts","sourceRoot":"","sources":["../../../src/lib/__tests__/release-136.test.ts"],"names":[],"mappings":""}