@metron-labs/quote-react 0.1.58 → 0.1.60

package/dist/lib/estimators/fixedProducts.js

@@ -10,23 +10,23 @@ import { getQuoteConfig } from "../config";
 const FIXED_PRODUCTS = {
     // FORT
     "NZ4Y-ZMSQ": {
-        "brick-block": { "brick-common": "105499", "brick-engineering-red": "1654", "brick-engineering-blue": "1723", block: "501", mortar: "646" },
+        "brick-block": { "brick-common": "105499", "brick-engineering-red": "1654", "brick-engineering-blue": "1723", block: "501", "mortar-cement": "1762 cement", "mortar-sand": "564 building sand" },
         // Primed MDF, 4.4m lengths. Ogee and torus come in 119mm skirting / 69mm architrave; the other
         // profiles only in 94mm and 144mm, so the nearer usable width is taken. FORT has no ovolo.
         skirting: { "skirting-chamfered": "1525", "skirting-ogee": "135 primed mdf ogee", "skirting-pencil-round": "892", "skirting-torus": "1941" },
         architrave: { "architrave-ogee": "134 primed mdf ogee", "architrave-ovolo": "1531", "architrave-pencil-round": "1896", "architrave-square-edge": "118 primed mdf square", "architrave-torus": "1531" },
         // Board keys come from the board type; see fixedProductSearch.
         plasterboard: { standard: "1647", moisture: "11 moisture plasterboard", fire: "14 fire plasterboard", sound: "1769", screws: "131160", tape: "1766", adhesive: "108439" },
-        insulation: { "insulation-floor": "152187", "insulation-wall": "147", "insulation-roof": "442", "insulation-loft": "152180" },
+        insulation: { "insulation-floor": "152187", "insulation-ground": "442", "insulation-wall": "147", "insulation-roof": "442", "insulation-loft": "152180" },
         timber: { studs: "1213", joists: "208", battens: "1729" },
         fencing: {
             "panels-boundary-0.9": "66 lap fence panel", "panels-boundary-1.2": "1450", "panels-boundary-1.5": "1449", "panels-boundary-1.8": "1448",
             "panels-skyline-1.8": "1475",
             "concrete-intermediate-8": "40197", "concrete-end-8": "40198",
-            "timber-post-6": "141411", "timber-post-8": "1709", postcrete: "12142", gate: "1984", "gravel-boards": "40200",
+            "timber-post-6": "141411", "timber-post-8": "1709", postcrete: "12142", "gate-boundary": "1984", "gate-skyline": "40002", "gravel-boards": "40200",
         },
         decking: { "boards-summit": "24322", joists: "208", screws: "131079" },
-        paving: { "surface-council": "23995", "surface-raj": "12369", "surface-brindle": "304", "surface-charcoal": "296", "surface-pea": "431", "sub-base": "569", bedding: "563" },
+        paving: { "surface-council": "1669", "surface-raj": "12363", "surface-brindle": "304", "surface-charcoal": "296", "surface-pea": "431", "sub-base": "569", bedding: "563" },
     },
 };
 /** The catalogue search for this line's fixed product, or null when the active client has none. */

package/dist/lib/estimators/requestUnit.d.ts

@@ -0,0 +1,12 @@
+import type { MatchCandidate } from "../../util/types";
+/**
+ * The unit to ask the basket for, given the product chosen for an estimator line. Only for
+ * estimator lines: a customer's "3 rolls" matched to a 2-roll pack is a different question.
+ * - A bag/box/roll/pack count is already a count of the product's packs - the estimator did that
+ *   sum - so it is asked as listed-price units ("sales_unit") where the catalogue supports them,
+ *   otherwise in the product's own unit when that product is sold one item at a time.
+ * - An "each" count of whole items (a gate, a panel) is asked as listed-price units only when one
+ *   listed-price unit is exactly one item, so 600 bricks priced per 1,000 stays 600 each.
+ * 3 bags must never become 3 tonnes or 3 x 1000.
+ */
+export declare function estimateRequestUnit(unit: string, candidate: MatchCandidate | null | undefined): string;

package/dist/lib/estimators/requestUnit.js

@@ -0,0 +1,28 @@
+// Kept free of runtime imports so plain Node can load it (Boq's quickOrder.check.ts does).
+const PACK_UNITS = new Set(["bag", "box", "roll", "pack"]);
+const SINGLE_ITEM_UNITS = new Set(["each", "bag", "box", "roll", "pack", "tub"]);
+/**
+ * The unit to ask the basket for, given the product chosen for an estimator line. Only for
+ * estimator lines: a customer's "3 rolls" matched to a 2-roll pack is a different question.
+ * - A bag/box/roll/pack count is already a count of the product's packs - the estimator did that
+ *   sum - so it is asked as listed-price units ("sales_unit") where the catalogue supports them,
+ *   otherwise in the product's own unit when that product is sold one item at a time.
+ * - An "each" count of whole items (a gate, a panel) is asked as listed-price units only when one
+ *   listed-price unit is exactly one item, so 600 bricks priced per 1,000 stays 600 each.
+ * 3 bags must never become 3 tonnes or 3 x 1000.
+ */
+export function estimateRequestUnit(unit, candidate) {
+    const supported = (candidate?.conversion?.request_uoms_supported ?? "").split(",").map((entry) => entry.trim().toLowerCase());
+    const salesUnits = supported.includes("sales_unit");
+    if (unit === "each") {
+        const oneItemPerPrice = (candidate?.uoi_count ?? 1) === 1 && (candidate?.conversion?.sales_unit_size ?? 1) === 1;
+        return salesUnits && oneItemPerPrice ? "sales_unit" : unit;
+    }
+    if (!PACK_UNITS.has(unit))
+        return unit;
+    if (salesUnits)
+        return "sales_unit";
+    const uoi = candidate?.uoi;
+    const singleItem = uoi != null && SINGLE_ITEM_UNITS.has(uoi.toLowerCase()) && (candidate?.uoi_count ?? 1) === 1;
+    return singleItem ? uoi : unit;
+}

package/dist/lib/estimators/resolveProducts.d.ts

@@ -11,13 +11,7 @@ export interface CatalogueStatus {
 }
 /** With an account code, prices come back net of that trade account's discounts. */
 export declare function searchCatalogue(query: string, category?: string, limit?: number, account?: string): Promise<MatchCandidate[]>;
-/**
- * The unit to ask the basket for. A bag/box/roll/pack count is already a count of the product's
- * sell units - the estimator did that sum - so it is asked in the product's own unit. A catalogue
- * that sells the same bag "each" would otherwise refuse the line and leave it unpriced. Only a
- * product sold one item at a time qualifies: 3 bags must never become 3 tonnes or 3 x 1000.
- */
-export declare function estimateRequestUnit(unit: string, candidate: MatchCandidate | null | undefined): string;
+export { estimateRequestUnit } from "./requestUnit";
 /**
  * Looks up every requirement in one go - the one place both the customer calculators and
  * Metron's internal tool turn calculator lines into products. With the calculator's `tool`, a

package/dist/lib/estimators/resolveProducts.js

@@ -44,19 +44,7 @@ export async function searchCatalogue(query, category, limit = 12, account) {
     cache.set(cacheKey, candidates);
     return candidates;
 }
-const PACK_UNITS = new Set(["bag", "box", "roll", "pack"]);
-const SINGLE_ITEM_UNITS = new Set(["each", "bag", "box", "roll", "pack", "tub"]);
-/**
- * The unit to ask the basket for. A bag/box/roll/pack count is already a count of the product's
- * sell units - the estimator did that sum - so it is asked in the product's own unit. A catalogue
- * that sells the same bag "each" would otherwise refuse the line and leave it unpriced. Only a
- * product sold one item at a time qualifies: 3 bags must never become 3 tonnes or 3 x 1000.
- */
-export function estimateRequestUnit(unit, candidate) {
-    const uoi = candidate?.uoi;
-    const singleItem = uoi != null && SINGLE_ITEM_UNITS.has(uoi.toLowerCase()) && (candidate?.uoi_count ?? 1) === 1;
-    return PACK_UNITS.has(unit) && singleItem ? uoi : unit;
-}
+export { estimateRequestUnit } from "./requestUnit";
 /**
  * Looks up every requirement in one go - the one place both the customer calculators and
  * Metron's internal tool turn calculator lines into products. With the calculator's `tool`, a
@@ -76,7 +64,7 @@ export async function resolveRequirements(requirements, account, tool) {
                 searchCatalogue(requirement.query, requirement.category, undefined, account),
             ]);
             const candidates = fixed ? [fixed, ...found.filter((item) => item.product_id !== fixed.product_id)] : found;
-            return { requirement: { ...requirement, unit: estimateRequestUnit(requirement.unit, candidates[0]) }, candidates };
+            return { requirement, candidates };
         }
         catch {
             return { requirement, candidates: [] };

package/dist/util/pricing.js

@@ -18,6 +18,8 @@ const unitAliases = {
     units: "each",
     pc: "each",
     pcs: "each",
+    piece: "each",
+    pieces: "each",
     board: "sheet",
     bags: "bag",
     length: "length",
@@ -140,6 +142,25 @@ export function getPricingBreakdown(item, options) {
     });
     if (!Number.isFinite(requestedAmount) || requestedAmount <= 0)
         return review("Quantity needs confirmation.");
+    // "sales_unit" means one listed-price unit, whatever it holds: 1 sales_unit of a box of
+    // 1,000 screws priced "per Each" is one box at the listed price. The estimators ask for it
+    // when they have already counted packs (see estimateRequestUnit).
+    if (requestedUnit === "sales_unit") {
+        const priceUnit = canonicalUnit(item.uoi) || sellUnit;
+        const required = hasOverride ? overriddenSellUnits : roundQuantity(requestedAmount * (1 + wasteFactor), item.roundingRule ?? "round_up_each");
+        return {
+            requestedAmount,
+            requestedUnit: priceUnit,
+            salesUnitSize: 1,
+            sellUnit: priceUnit,
+            calculatedSellUnits: required,
+            requiredSellUnits: required,
+            unitPrice: item.price,
+            lineTotal: item.price != null ? item.price * required : null,
+            calculation: `${requestedAmount} ${priceUnit}${wasteFactor > 0 ? ` x ${1 + wasteFactor}` : ""} = ${required} ${priceUnit}`,
+            costingMode: "direct",
+        };
+    }
     if (!supportsRequestedUnit(item, requestedUnit)) {
         return review("Requested unit is not supported by this catalogue conversion.");
     }
@@ -250,13 +271,15 @@ export function getPricingBreakdown(item, options) {
             calculation = `${requestedAmount} ${requestedUnit} x ${wasteMultiplier} / ${item.coverageQty} ${item.coverageUom} per ${sellUnit}`;
         }
     }
-    else if (item.conversionType === "weight_from_description") {
+    else if (item.conversionType === "weight_from_description" || item.conversionType === "mass_from_pack") {
+        // mass_from_pack (newer catalogue rows) states the unit as "kg per price unit"; the weight unit is its first word.
+        const coverageUnit = canonicalUnit((item.coverageUom ?? "").split(" ")[0]);
         const requestedWeightG = weightInG(requestedAmount, requestedUnit);
-        const coverageWeightG = weightInG(item.coverageQty ?? 0, canonicalUnit(item.coverageUom));
+        const coverageWeightG = weightInG(item.coverageQty ?? 0, coverageUnit);
         if (requestedWeightG != null && coverageWeightG != null && coverageWeightG > 0) {
             rawSellUnits = (requestedWeightG * wasteMultiplier) / coverageWeightG;
             costingMode = "derived";
-            calculation = `${requestedAmount} ${requestedUnit} x ${wasteMultiplier} / ${item.coverageQty} ${item.coverageUom} per ${sellUnit}`;
+            calculation = `${requestedAmount} ${requestedUnit} x ${wasteMultiplier} / ${item.coverageQty} ${coverageUnit} per ${sellUnit}`;
         }
     }
     else if (item.conversionType === "same_unit_volume") {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@metron-labs/quote-react",
-  "version": "0.1.58",
+  "version": "0.1.60",
   "description": "Metron Labs quote and estimating calculator components for React",
   "license": "UNLICENSED",
   "sideEffects": [