@metron-labs/quote-react 0.1.46 → 0.1.48

package/dist/lib/cart/CartContext.d.ts

@@ -13,6 +13,8 @@ interface CartApi {
     /** Show the basket. Each app decides what that means for its own navigation. */
     openBasket: () => void;
 }
+/** The inputs that can change a conversion, including the selected parent of a dependent line. */
+export declare function conversionInputKey(item: Pick<CartItem, "productId" | "qty" | "unit" | "linkedContext">): string;
 export declare function refreshLinkedDependents(cart: Record<string, CartItem>, anchorItem: CartItem): Record<string, CartItem>;
 /**
  * One basket per app. BoQApp and EstimatingToolsApp each mount their own provider, so a

package/dist/lib/cart/CartContext.js

@@ -1,6 +1,10 @@
 "use client";
 import { jsx as _jsx } from "react/jsx-runtime";
 import { createContext, useCallback, useContext, useMemo, useState } from "react";
+/** The inputs that can change a conversion, including the selected parent of a dependent line. */
+export function conversionInputKey(item) {
+    return JSON.stringify([item.productId, item.qty, item.unit, item.linkedContext ?? []]);
+}
 export function refreshLinkedDependents(cart, anchorItem) {
     const next = { ...cart, [anchorItem.lineId]: anchorItem };
     for (const [lineId, dependent] of Object.entries(next)) {

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

@@ -1,4 +1,7 @@
 import type { EstimatorToolId } from "../../components/estimators/registry";
 import type { FixedBasketLine } from "../../components/estimators/useFixedBasket";
 import type { EstimatorRequirement } from "./types";
+/** The catalogue search for this line's fixed product, or null when the active client has none. */
+export declare function fixedProductSearch(tool: EstimatorToolId, requirement: EstimatorRequirement): string | null;
+/** Basket lines when every line has a fixed product, so the calculator can skip the matching step. */
 export declare function fixedBasketLines(tool: EstimatorToolId, requirements: EstimatorRequirement[]): FixedBasketLine[] | null;

package/dist/lib/estimators/fixedProducts.js

@@ -1,32 +1,48 @@
-const productFor = (tool, requirement) => {
-    const key = requirement.key;
-    const products = {
-        "brick-block": { "brick-common": "5001444", "brick-engineering-red": "5002008", "brick-engineering-blue": "5001439", block: "5003187", mortar: "6003088" },
-        skirting: { "skirting-chamfered": "4006057", "skirting-ogee": "4006045", "skirting-pencil-round": "4006048", "skirting-torus": "4006042" },
-        architrave: { "architrave-ogee": "4006060", "architrave-ovolo": "4006063", "architrave-pencil-round": "4006061", "architrave-square-edge": "4006062", "architrave-torus": "4006059" },
-        plasterboard: { board: "2001035", screws: "2006040", tape: "2007043", adhesive: "2004023" },
-        insulation: { "insulation-floor": "3002110", "insulation-wall": "3002012", "insulation-roof": "3004047", "insulation-loft": "3003046" },
-        timber: { studs: "4001168", joists: "4001201", battens: "4001053" },
+import { getQuoteConfig } from "../config";
+// The exact product each calculator line orders, per client. Each value is the catalogue search
+// that finds it: the ID, plus a few words where the ID alone is too short to surface it (search
+// matches IDs as substrings, so "11" alone hits hundreds of products). A client or line with no
+// entry falls back to catalogue search.
+//
+// ponytail: hand-kept table in the package, for one client. It belongs in the backend, per client
+// code - when it moves, only fixedProductSearch changes (to read it from the API); every caller
+// goes through that.
+const FIXED_PRODUCTS = {
+    // FORT
+    "NZ4Y-ZMSQ": {
+        "brick-block": { "brick-common": "105499", "brick-engineering-red": "1654", "brick-engineering-blue": "1723", block: "501", mortar: "646" },
+        // 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" },
+        timber: { studs: "1213", joists: "208", battens: "1729" },
         fencing: {
-            "panels-boundary-0.9": "4001268", "panels-boundary-1.2": "4001269", "panels-boundary-1.5": "4001270", "panels-boundary-1.8": "4001271",
-            "panels-skyline-0.9": "4001264", "panels-skyline-1.2": "4001265", "panels-skyline-1.5": "4001266", "panels-skyline-1.8": "4001267",
-            "concrete-intermediate-6": "4001290", "concrete-intermediate-8": "4001291", "concrete-end-6": "4001294", "concrete-end-8": "4001295",
-            "timber-post-6": "4001242", "timber-post-8": "4001243", postcrete: "6003008", gate: "4001630", "gravel-boards": "4001284",
+            "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",
         },
-        decking: { "boards-meridian": "4001251", "boards-summit": "4001360", joists: "4001201", screws: "1001103" },
-        paving: { "surface-council": "7003121", "surface-raj": "7003003", "surface-brindle": "4001621", "surface-charcoal": "4001622", "surface-pea": "6001004", "sub-base": "6001007", bedding: "6001012" },
-    };
-    if (tool === "plasterboard") {
-        return { standard: "2001035", moisture: "2002039", fire: "2002087", sound: "2002044" }[requirement.label.split(" ")[0].toLowerCase()] ?? products[tool]?.[key] ?? null;
-    }
-    return products[tool]?.[key] ?? null;
+        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" },
+    },
 };
-export function fixedBasketLines(tool, requirements) {
-    if (tool === "paint" || tool === "concrete-aggregate")
+/** The catalogue search for this line's fixed product, or null when the active client has none. */
+export function fixedProductSearch(tool, requirement) {
+    const table = FIXED_PRODUCTS[getQuoteConfig().client ?? ""]?.[tool];
+    if (!table)
         return null;
+    // The plasterboard line is keyed "board" whatever the board; its label starts with the type.
+    const key = tool === "plasterboard" && requirement.key === "board" ? requirement.label.split(" ")[0].toLowerCase() : requirement.key;
+    return table[key] ?? null;
+}
+/** Basket lines when every line has a fixed product, so the calculator can skip the matching step. */
+export function fixedBasketLines(tool, requirements) {
     const lines = requirements.map((requirement) => {
-        const productId = productFor(tool, requirement);
-        return productId ? { key: requirement.key, productId, qty: requirement.qty, unit: requirement.unit } : null;
+        const search = fixedProductSearch(tool, requirement);
+        return search ? { key: requirement.key, productId: search.split(" ")[0], search, qty: requirement.qty, unit: requirement.unit } : null;
     });
-    return lines.every(Boolean) ? lines : null;
+    return lines.length > 0 && lines.every(Boolean) ? lines : null;
 }

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

@@ -1,4 +1,5 @@
 import type { MatchCandidate } from "../../util/types";
+import type { EstimatorToolId } from "../../components/estimators/registry";
 import type { EstimatorRequirement } from "./types";
 export interface ResolvedRequirement {
     requirement: EstimatorRequirement;
@@ -11,11 +12,20 @@ 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[]>;
 /**
- * Looks up every requirement in one go. A requirement that matches nothing comes back
- * with an empty candidate list rather than being dropped, so the results step can say
- * so instead of quietly shortening the materials list.
+ * 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 resolveRequirements(requirements: EstimatorRequirement[], account?: string): Promise<ResolvedRequirement[]>;
+export declare function estimateRequestUnit(unit: string, candidate: MatchCandidate | null | undefined): string;
+/**
+ * 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
+ * line the client has a fixed product for gets that product first, ahead of the search results.
+ * A requirement that matches nothing comes back with an empty candidate list rather than being
+ * dropped, so the results step can say so instead of quietly shortening the materials list.
+ */
+export declare function resolveRequirements(requirements: EstimatorRequirement[], account?: string, tool?: EstimatorToolId): Promise<ResolvedRequirement[]>;
 /**
  * Whether this client has a catalogue at all. Merchants without one still get working
  * calculators - they just don't get the basket step.

package/dist/lib/estimators/resolveProducts.js

@@ -1,5 +1,6 @@
 import { apiHeaders, readJson } from "../api/boqClient";
-import { apiUrl } from "../config";
+import { apiUrl, getQuoteConfig } from "../config";
+import { fixedProductSearch } from "./fixedProducts";
 // Estimator queries repeat constantly - the same "skirting board" search fires on every
 // recalculation - so results are memoised for the tab's lifetime. Nothing here is
 // user-specific beyond the client the headers already scope it to.
@@ -24,8 +25,9 @@ function toCandidate(item) {
 }
 /** With an account code, prices come back net of that trade account's discounts. */
 export async function searchCatalogue(query, category, limit = 12, account) {
-    // The account is part of the key: the same search is a different price for each account.
-    const cacheKey = `${query}||${category ?? ""}||${limit}||${account ?? ""}`;
+    // The client and account are part of the key: the same search is a different catalogue per
+    // client, and a different price per account.
+    const cacheKey = `${getQuoteConfig().client ?? ""}||${query}||${category ?? ""}||${limit}||${account ?? ""}`;
     const cached = cache.get(cacheKey);
     if (cached)
         return cached;
@@ -42,15 +44,39 @@ 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"]);
 /**
- * Looks up every requirement in one go. A requirement that matches nothing comes back
- * with an empty candidate list rather than being dropped, so the results step can say
- * so instead of quietly shortening the materials list.
+ * 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 async function resolveRequirements(requirements, account) {
+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;
+}
+/**
+ * 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
+ * line the client has a fixed product for gets that product first, ahead of the search results.
+ * A requirement that matches nothing comes back with an empty candidate list rather than being
+ * dropped, so the results step can say so instead of quietly shortening the materials list.
+ */
+export async function resolveRequirements(requirements, account, tool) {
     const results = await Promise.all(requirements.map(async (requirement) => {
         try {
-            return { requirement, candidates: await searchCatalogue(requirement.query, requirement.category, undefined, account) };
+            const fixedSearch = tool ? fixedProductSearch(tool, requirement) : null;
+            const [fixed, found] = await Promise.all([
+                // A failed fixed lookup leaves the line on search results rather than emptying it.
+                fixedSearch
+                    ? searchCatalogue(fixedSearch, undefined, undefined, account).then((items) => items.find((item) => item.product_id === fixedSearch.split(" ")[0]), () => undefined)
+                    : undefined,
+                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 };
         }
         catch {
             return { requirement, candidates: [] };

package/dist/styles.css

@@ -5813,12 +5813,11 @@
 }
 
 :where(.app-wrapper) .results-total-action small {
-  margin-bottom: 2px;
-  color: var(--text-mid);
-  font-size: 11px;
+  color: var(--text);
+  font-size: 15px;
   font-weight: 600;
-  letter-spacing: 0.04em;
-  text-transform: uppercase;
+  letter-spacing: 0;
+  text-transform: none;
 }
 
 :where(.app-wrapper) .results-total-action strong {

package/dist/util/pricing.d.ts

@@ -11,7 +11,7 @@ export interface PricingBreakdown {
     calculation: string;
     costingMode: "direct" | "derived" | "review";
 }
-export declare function getCartSubtotal(items: CartItem[], options?: Parameters<typeof getPricingBreakdown>[1]): number;
+export declare function getCartSubtotal(items: CartItem[], options?: Parameters<typeof getPricingBreakdown>[1]): number | null;
 export declare function getPricingBreakdown(item: CartItem, options?: {
     wasteFactorEnabled?: boolean;
     wasteFactorOverride?: number | null;

package/dist/util/pricing.js

@@ -112,7 +112,8 @@ const coverageFromDescription = (item, requestedUnit, sellUnit) => {
     return Number.isFinite(coverage) && coverage > 0 ? coverage : null;
 };
 export function getCartSubtotal(items, options) {
-    return items.reduce((sum, item) => sum + (getPricingBreakdown(item, options).lineTotal ?? 0), 0);
+    const totals = items.map((item) => getPricingBreakdown(item, options).lineTotal);
+    return totals.some((total) => total == null) ? null : totals.reduce((sum, total) => sum + (total ?? 0), 0);
 }
 export function getPricingBreakdown(item, options) {
     const requestedAmount = item.qty;
@@ -137,6 +138,8 @@ export function getPricingBreakdown(item, options) {
         calculation: overriddenSellUnits != null ? `${reason} Manually set to ${overriddenSellUnits} ${sellUnit}.` : reason,
         costingMode: "review",
     });
+    if (!Number.isFinite(requestedAmount) || requestedAmount <= 0)
+        return review("Quantity needs confirmation.");
     if (!supportsRequestedUnit(item, requestedUnit)) {
         return review("Requested unit is not supported by this catalogue conversion.");
     }

package/package.json

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