@merchi/sdk 1.40.2

package/dist/pricing/inventory.js

@@ -0,0 +1,238 @@
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+// Returns the set of option ids that should be DISABLED because the combination
+// of (current inventory-relevant selections + that option) has no matching
+// inventory with stock. Mirrors the server's subset match
+// (inventories.py `inventories_subset_match_strategy`): an inventory matches a
+// selection when it contains every selected option; an option is available if
+// any matching inventory has quantity > 0.
+//
+// Scope: pass the container's selections (independent fields use the top-level
+// selections; a group uses its own + independent). Only options that appear in
+// at least one inventory unit are inventory-tracked; all others are always
+// available. Direct product inventories only (no shared inventory groups).
+export function resolveUnavailableOptionIds(rules, selections) {
+    var e_1, _a, e_2, _b, e_3, _c, e_4, _d, e_5, _e, e_6, _f, e_7, _g;
+    var unavailable = new Set();
+    var units = rules.inventoryUnits || [];
+    if (units.length === 0)
+        return unavailable;
+    var allFields = __spreadArray(__spreadArray([], __read(rules.fields), false), __read(rules.groupFields), false);
+    // Canonicalise id/originalId to a single id per option so bundle option ids,
+    // selected ids and inventory unit ids all compare consistently.
+    var canonical = new Map();
+    var fieldIdByOption = new Map();
+    try {
+        for (var allFields_1 = __values(allFields), allFields_1_1 = allFields_1.next(); !allFields_1_1.done; allFields_1_1 = allFields_1.next()) {
+            var f = allFields_1_1.value;
+            try {
+                for (var _h = (e_2 = void 0, __values(f.options)), _j = _h.next(); !_j.done; _j = _h.next()) {
+                    var o = _j.value;
+                    canonical.set(o.id, o.id);
+                    fieldIdByOption.set(o.id, f.id);
+                    if (o.originalId != null) {
+                        canonical.set(o.originalId, o.id);
+                        fieldIdByOption.set(o.originalId, f.id);
+                    }
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (_j && !_j.done && (_b = _h.return)) _b.call(_h);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (allFields_1_1 && !allFields_1_1.done && (_a = allFields_1.return)) _a.call(allFields_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    var canon = function (id) { return (canonical.has(id) ? canonical.get(id) : id); };
+    var unitSets = units.map(function (u) { return ({
+        quantity: u.quantity,
+        optionIds: new Set(u.optionIds.map(canon)),
+    }); });
+    var inventoryOptionIds = new Set();
+    try {
+        for (var unitSets_1 = __values(unitSets), unitSets_1_1 = unitSets_1.next(); !unitSets_1_1.done; unitSets_1_1 = unitSets_1.next()) {
+            var u = unitSets_1_1.value;
+            try {
+                for (var _k = (e_4 = void 0, __values(u.optionIds)), _l = _k.next(); !_l.done; _l = _k.next()) {
+                    var id = _l.value;
+                    inventoryOptionIds.add(id);
+                }
+            }
+            catch (e_4_1) { e_4 = { error: e_4_1 }; }
+            finally {
+                try {
+                    if (_l && !_l.done && (_d = _k.return)) _d.call(_k);
+                }
+                finally { if (e_4) throw e_4.error; }
+            }
+        }
+    }
+    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+    finally {
+        try {
+            if (unitSets_1_1 && !unitSets_1_1.done && (_c = unitSets_1.return)) _c.call(unitSets_1);
+        }
+        finally { if (e_3) throw e_3.error; }
+    }
+    // Collect currently-selected, inventory-tracked option ids grouped by field.
+    var selectedByField = new Map();
+    var addSelections = function (fieldValues) {
+        var e_8, _a, e_9, _b;
+        try {
+            for (var _c = __values(Object.keys(fieldValues)), _d = _c.next(); !_d.done; _d = _c.next()) {
+                var key = _d.value;
+                var fieldId = Number(key);
+                var sel = fieldValues[fieldId];
+                if (!sel || !sel.selectedOptionIds)
+                    continue;
+                var set = selectedByField.get(fieldId) || new Set();
+                try {
+                    for (var _e = (e_9 = void 0, __values(sel.selectedOptionIds)), _f = _e.next(); !_f.done; _f = _e.next()) {
+                        var oid = _f.value;
+                        var c = canon(oid);
+                        if (inventoryOptionIds.has(c))
+                            set.add(c);
+                    }
+                }
+                catch (e_9_1) { e_9 = { error: e_9_1 }; }
+                finally {
+                    try {
+                        if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+                    }
+                    finally { if (e_9) throw e_9.error; }
+                }
+                selectedByField.set(fieldId, set);
+            }
+        }
+        catch (e_8_1) { e_8 = { error: e_8_1 }; }
+        finally {
+            try {
+                if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+            }
+            finally { if (e_8) throw e_8.error; }
+        }
+    };
+    addSelections(selections.fieldValues || {});
+    try {
+        for (var _m = __values(selections.groups || []), _o = _m.next(); !_o.done; _o = _m.next()) {
+            var group = _o.value;
+            addSelections(group.fieldValues || {});
+        }
+    }
+    catch (e_5_1) { e_5 = { error: e_5_1 }; }
+    finally {
+        try {
+            if (_o && !_o.done && (_e = _m.return)) _e.call(_m);
+        }
+        finally { if (e_5) throw e_5.error; }
+    }
+    var hasGroups = Boolean(selections.groups && selections.groups.length > 0);
+    var fieldsToConsider = hasGroups ? allFields : rules.fields;
+    try {
+        for (var fieldsToConsider_1 = __values(fieldsToConsider), fieldsToConsider_1_1 = fieldsToConsider_1.next(); !fieldsToConsider_1_1.done; fieldsToConsider_1_1 = fieldsToConsider_1.next()) {
+            var f = fieldsToConsider_1_1.value;
+            var _loop_1 = function (o) {
+                var e_10, _r, e_11, _s;
+                var candidate = canon(o.id);
+                if (!inventoryOptionIds.has(candidate))
+                    return "continue"; // not inventory-tracked
+                // filter = candidate + selected inventory options from OTHER fields.
+                var filter = [candidate];
+                try {
+                    for (var selectedByField_1 = (e_10 = void 0, __values(selectedByField)), selectedByField_1_1 = selectedByField_1.next(); !selectedByField_1_1.done; selectedByField_1_1 = selectedByField_1.next()) {
+                        var _t = __read(selectedByField_1_1.value, 2), fieldId = _t[0], set = _t[1];
+                        if (fieldId === f.id)
+                            continue;
+                        try {
+                            for (var set_1 = (e_11 = void 0, __values(set)), set_1_1 = set_1.next(); !set_1_1.done; set_1_1 = set_1.next()) {
+                                var sid = set_1_1.value;
+                                filter.push(sid);
+                            }
+                        }
+                        catch (e_11_1) { e_11 = { error: e_11_1 }; }
+                        finally {
+                            try {
+                                if (set_1_1 && !set_1_1.done && (_s = set_1.return)) _s.call(set_1);
+                            }
+                            finally { if (e_11) throw e_11.error; }
+                        }
+                    }
+                }
+                catch (e_10_1) { e_10 = { error: e_10_1 }; }
+                finally {
+                    try {
+                        if (selectedByField_1_1 && !selectedByField_1_1.done && (_r = selectedByField_1.return)) _r.call(selectedByField_1);
+                    }
+                    finally { if (e_10) throw e_10.error; }
+                }
+                var available = unitSets.some(function (u) { return u.quantity > 0 && filter.every(function (id) { return u.optionIds.has(id); }); });
+                if (!available)
+                    unavailable.add(o.id);
+            };
+            try {
+                for (var _p = (e_7 = void 0, __values(f.options)), _q = _p.next(); !_q.done; _q = _p.next()) {
+                    var o = _q.value;
+                    _loop_1(o);
+                }
+            }
+            catch (e_7_1) { e_7 = { error: e_7_1 }; }
+            finally {
+                try {
+                    if (_q && !_q.done && (_g = _p.return)) _g.call(_p);
+                }
+                finally { if (e_7) throw e_7.error; }
+            }
+        }
+    }
+    catch (e_6_1) { e_6 = { error: e_6_1 }; }
+    finally {
+        try {
+            if (fieldsToConsider_1_1 && !fieldsToConsider_1_1.done && (_f = fieldsToConsider_1.return)) _f.call(fieldsToConsider_1);
+        }
+        finally { if (e_6) throw e_6.error; }
+    }
+    return unavailable;
+}

package/dist/pricing/inventory.test.js

@@ -0,0 +1,188 @@
+import { resolveUnavailableOptionIds } from './inventory.js';
+// Size (24mm=801, 25mm=802) x Colour (Red=811, Green=812, Blue=813), with
+// per-combination stock. 25mm-Blue = 0; 19mm/24mm-Blue has stock.
+function rules(inventoryUnits) {
+    var opt = function (id) { return ({
+        id: id,
+        originalId: id, position: id, default: false,
+        variationCost: 0, variationUnitCost: 0,
+        variationCostDiscountGroup: null, variationUnitCostDiscountGroup: null,
+        selectedBy: [],
+    }); };
+    var f = function (id, options) { return ({
+        id: id,
+        originalId: id, position: 0, fieldType: 2, independent: false,
+        isSelectable: true, selectedBy: [],
+        variationCost: 0, variationUnitCost: 0,
+        variationCostDiscountGroup: null, variationUnitCostDiscountGroup: null,
+        options: options.map(opt),
+    }); };
+    return {
+        currency: 'AUD', taxPercent: 0,
+        product: { unitPrice: 0, minimumPrice: null, discountGroup: null },
+        fields: [], hasGroups: true, needsInventory: true,
+        groupFields: [f(800, [801, 802]), f(810, [811, 812, 813])],
+        inventoryUnits: inventoryUnits,
+    };
+}
+var units = [
+    { optionIds: [801, 813], quantity: 5 },
+    { optionIds: [802, 811], quantity: 7 },
+    { optionIds: [802, 812], quantity: 7 },
+    { optionIds: [802, 813], quantity: 0 }, // 25mm-Blue: OUT OF STOCK
+];
+test('no inventory units -> nothing unavailable', function () {
+    var r = rules([]);
+    expect(resolveUnavailableOptionIds(r, { fieldValues: {}, groups: [{ quantity: 1, fieldValues: {} }] }).size).toBe(0);
+});
+test('with no other selection, an option with stock somewhere is available', function () {
+    var r = rules(units);
+    // Nothing selected: Blue has stock as 24mm-Blue, so not unavailable.
+    var u = resolveUnavailableOptionIds(r, { fieldValues: {}, groups: [{ quantity: 1, fieldValues: {} }] });
+    expect(u.has(813)).toBe(false);
+});
+test('25mm makes Blue unavailable but keeps Red/Green available', function () {
+    var r = rules(units);
+    var u = resolveUnavailableOptionIds(r, {
+        fieldValues: {},
+        groups: [{ quantity: 1, fieldValues: { 800: { selectedOptionIds: [802] } } }],
+    });
+    expect(u.has(813)).toBe(true); // 25mm-Blue = 0 -> Blue disabled
+    expect(u.has(811)).toBe(false); // 25mm-Red ok
+    expect(u.has(812)).toBe(false); // 25mm-Green ok
+});
+test('selecting Blue makes 25mm unavailable (combination-aware both directions)', function () {
+    var r = rules(units);
+    var u = resolveUnavailableOptionIds(r, {
+        fieldValues: {},
+        groups: [{ quantity: 1, fieldValues: { 810: { selectedOptionIds: [813] } } }],
+    });
+    expect(u.has(802)).toBe(true); // 25mm + Blue = 0 -> 25mm disabled
+    expect(u.has(801)).toBe(false); // 24mm + Blue = 5 -> 24mm ok
+});
+test('per-group scope: one group selecting 25mm does not disable Blue in another', function () {
+    var r = rules(units);
+    var u = resolveUnavailableOptionIds(r, {
+        fieldValues: {},
+        groups: [{ quantity: 1, fieldValues: { 800: { selectedOptionIds: [801] } } }],
+    });
+    // 24mm selected here -> 24mm-Blue has stock -> Blue available.
+    expect(u.has(813)).toBe(false);
+});
+test('omitted inventoryUnits -> nothing unavailable', function () {
+    var r = rules(units);
+    delete r.inventoryUnits;
+    expect(resolveUnavailableOptionIds(r, { fieldValues: {} }).size).toBe(0);
+});
+test('non-group product: top-level selections drive availability', function () {
+    var opt = function (id) { return ({
+        id: id,
+        originalId: null, position: id, default: false,
+        variationCost: 0, variationUnitCost: 0,
+        variationCostDiscountGroup: null, variationUnitCostDiscountGroup: null,
+        selectedBy: [],
+    }); };
+    var f = function (id, options) { return ({
+        id: id,
+        originalId: id, position: 0, fieldType: 2, independent: true,
+        isSelectable: true, selectedBy: [],
+        variationCost: 0, variationUnitCost: 0,
+        variationCostDiscountGroup: null, variationUnitCostDiscountGroup: null,
+        options: options.map(opt),
+    }); };
+    var r = {
+        currency: 'AUD', taxPercent: 0,
+        product: { unitPrice: 0, minimumPrice: null, discountGroup: null },
+        hasGroups: false, needsInventory: true,
+        fields: [f(800, [801, 802]), f(810, [811, 813])],
+        groupFields: [],
+        inventoryUnits: [
+            { optionIds: [802, 811], quantity: 7 },
+            { optionIds: [802, 813], quantity: 0 }, // 25mm-Blue OUT
+        ],
+    };
+    var u = resolveUnavailableOptionIds(r, {
+        quantity: 1,
+        fieldValues: { 800: { selectedOptionIds: [802] } },
+    });
+    expect(u.has(813)).toBe(true); // 25mm-Blue unavailable
+    expect(u.has(811)).toBe(false); // 25mm-Red ok
+});
+test('non-inventory options and non-selection field values are ignored', function () {
+    var r = rules(units);
+    // Field 810 option 999 is not in any unit (not tracked); a value-only field
+    // and an undefined selection entry exercise the skip branches.
+    r.groupFields[1].options.push({
+        id: 999, originalId: null, position: 9, default: false,
+        variationCost: 0, variationUnitCost: 0,
+        variationCostDiscountGroup: null, variationUnitCostDiscountGroup: null,
+        selectedBy: [],
+    });
+    var u = resolveUnavailableOptionIds(r, {
+        fieldValues: { 700: { value: 'text' }, 701: undefined },
+        groups: [{ quantity: 1, fieldValues: { 800: { selectedOptionIds: [802] }, 810: { selectedOptionIds: [999] } } }],
+    });
+    expect(u.has(999)).toBe(false); // untracked option is always available
+    expect(u.has(813)).toBe(true); // 25mm-Blue still unavailable
+});
+test('undefined top-level fieldValues and group fieldValues are tolerated', function () {
+    var r = rules(units);
+    var u = resolveUnavailableOptionIds(r, {
+        fieldValues: undefined,
+        groups: [{ quantity: 1, fieldValues: undefined }],
+    });
+    // No selections -> only options with zero stock everywhere would be flagged;
+    // every option here has stock in some combo, so none unavailable.
+    expect(u.size).toBe(0);
+});
+test('same field selected at top level and in a group merges selections', function () {
+    var r = rules(units);
+    var u = resolveUnavailableOptionIds(r, {
+        fieldValues: { 800: { selectedOptionIds: [802] } },
+        groups: [{ quantity: 1, fieldValues: { 800: { selectedOptionIds: [802] } } }],
+    });
+    expect(u.has(813)).toBe(true); // 25mm selected (both scopes) -> Blue unavailable
+});
+test('unit referencing an unknown option id falls back to the raw id', function () {
+    var r = rules([
+        { optionIds: [802, 813], quantity: 0 },
+        { optionIds: [802, 5555], quantity: 9 }, // 5555 not a known option
+    ]);
+    // 25mm + Blue still 0; the unknown id just never matches a selection.
+    var u = resolveUnavailableOptionIds(r, {
+        fieldValues: {},
+        groups: [{ quantity: 1, fieldValues: { 800: { selectedOptionIds: [802] } } }],
+    });
+    expect(u.has(813)).toBe(true);
+});
+test('originalId is canonicalised when matching units', function () {
+    var opt = function (id, originalId) { return ({
+        id: id,
+        originalId: originalId,
+        position: id, default: false,
+        variationCost: 0, variationUnitCost: 0,
+        variationCostDiscountGroup: null, variationUnitCostDiscountGroup: null,
+        selectedBy: [],
+    }); };
+    var r = {
+        currency: 'AUD', taxPercent: 0,
+        product: { unitPrice: 0, minimumPrice: null, discountGroup: null },
+        fields: [], hasGroups: true, needsInventory: true,
+        groupFields: [
+            {
+                id: 800, originalId: 800, position: 0, fieldType: 2, independent: false,
+                isSelectable: true, selectedBy: [],
+                variationCost: 0, variationUnitCost: 0,
+                variationCostDiscountGroup: null, variationUnitCostDiscountGroup: null,
+                options: [opt(900, 802)], // cloned option 900 whose original is 802
+            },
+        ],
+        // inventory references the original id 802
+        inventoryUnits: [{ optionIds: [802], quantity: 0 }],
+    };
+    var u = resolveUnavailableOptionIds(r, {
+        fieldValues: {},
+        groups: [{ quantity: 1, fieldValues: {} }],
+    });
+    expect(u.has(900)).toBe(true); // original 802 has 0 stock -> cloned 900 unavailable
+});

package/dist/pricing/matrix.js

@@ -0,0 +1,245 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+import { estimateQuote } from './estimate.js';
+function toQuantity(value) {
+    var n = Number(value);
+    return Number.isFinite(n) ? n : 0;
+}
+function floorMinQuantity(value) {
+    var n = toQuantity(value);
+    return n >= 1 ? Math.round(n) : 1;
+}
+function addDiscountLimits(group, limits, minQuantity) {
+    var e_1, _a;
+    if (!group || !group.discounts)
+        return;
+    try {
+        for (var _b = __values(group.discounts), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var discount = _c.value;
+            var n = Number(discount.lowerLimit);
+            if (!Number.isFinite(n))
+                continue;
+            var qty = Math.round(n);
+            if (qty > minQuantity)
+                limits.add(qty);
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+}
+function collectFieldDiscountLimits(field, limits, minQuantity) {
+    var e_2, _a;
+    addDiscountLimits(field.variationCostDiscountGroup, limits, minQuantity);
+    addDiscountLimits(field.variationUnitCostDiscountGroup, limits, minQuantity);
+    addDiscountLimits(field.heightVariationCostDiscountGroup, limits, minQuantity);
+    addDiscountLimits(field.heightVariationUnitCostDiscountGroup, limits, minQuantity);
+    addDiscountLimits(field.widthVariationCostDiscountGroup, limits, minQuantity);
+    addDiscountLimits(field.widthVariationUnitCostDiscountGroup, limits, minQuantity);
+    try {
+        for (var _b = __values(field.options), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var option = _c.value;
+            addDiscountLimits(option.variationCostDiscountGroup, limits, minQuantity);
+            addDiscountLimits(option.variationUnitCostDiscountGroup, limits, minQuantity);
+        }
+    }
+    catch (e_2_1) { e_2 = { error: e_2_1 }; }
+    finally {
+        try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+        }
+        finally { if (e_2) throw e_2.error; }
+    }
+}
+function collectQuantityBreaks(rules, minQuantity) {
+    var e_3, _a, e_4, _b;
+    var limits = new Set([minQuantity]);
+    addDiscountLimits(rules.product.discountGroup, limits, minQuantity);
+    try {
+        for (var _c = __values(rules.fields), _d = _c.next(); !_d.done; _d = _c.next()) {
+            var item = _d.value;
+            collectFieldDiscountLimits(item, limits, minQuantity);
+        }
+    }
+    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+    finally {
+        try {
+            if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+        }
+        finally { if (e_3) throw e_3.error; }
+    }
+    try {
+        for (var _e = __values(rules.groupFields), _f = _e.next(); !_f.done; _f = _e.next()) {
+            var item = _f.value;
+            collectFieldDiscountLimits(item, limits, minQuantity);
+        }
+    }
+    catch (e_4_1) { e_4 = { error: e_4_1 }; }
+    finally {
+        try {
+            if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+        }
+        finally { if (e_4) throw e_4.error; }
+    }
+    return Array.from(limits).sort(function (a, b) { return a - b; });
+}
+function groupHasValues(group) {
+    var values = group.fieldValues || {};
+    return Object.keys(values).some(function (key) {
+        var selection = values[Number(key)];
+        if (!selection)
+            return false;
+        if (selection.selectedOptionIds && selection.selectedOptionIds.length) {
+            return true;
+        }
+        var value = selection.value;
+        return !(value === undefined ||
+            value === null ||
+            value === '' ||
+            value === 0);
+    });
+}
+function representativeGroupIndex(groups) {
+    var idx = groups.findIndex(groupHasValues);
+    return idx >= 0 ? idx : 0;
+}
+function selectionsAtQuantity(selections, qty) {
+    var groups = selections.groups;
+    if (groups && groups.length > 0) {
+        var quantities = groups.map(function (group) { return toQuantity(group.quantity); });
+        var total = quantities.reduce(function (sum, value) { return sum + value; }, 0);
+        if (total <= 0) {
+            var idx_1 = representativeGroupIndex(groups);
+            return {
+                fieldValues: selections.fieldValues || {},
+                groups: groups.map(function (group, i) { return (__assign(__assign({}, group), { quantity: i === idx_1 ? qty : 0 })); }),
+            };
+        }
+        var scaled_1 = new Array(groups.length).fill(0);
+        var allocated = 0;
+        for (var i = 0; i < groups.length - 1; i++) {
+            scaled_1[i] = Math.round((quantities[i] / total) * qty);
+            allocated += scaled_1[i];
+        }
+        scaled_1[groups.length - 1] = Math.max(0, qty - allocated);
+        return {
+            fieldValues: selections.fieldValues || {},
+            groups: groups.map(function (group, i) { return (__assign(__assign({}, group), { quantity: scaled_1[i] })); }),
+        };
+    }
+    return {
+        fieldValues: selections.fieldValues || {},
+        quantity: qty,
+    };
+}
+function formatBandLabel(quantity, upperLimit) {
+    if (upperLimit == null)
+        return "".concat(quantity, "+");
+    if (upperLimit === quantity)
+        return "".concat(quantity);
+    return "".concat(quantity, "\u2013").concat(upperLimit);
+}
+function samePrice(a, b) {
+    return (Math.abs(a.costPerUnit - b.costPerUnit) < 0.001 &&
+        Math.abs(a.unitPrice - b.unitPrice) < 0.001);
+}
+function withBandBounds(quantities) {
+    return quantities.map(function (quantity, i) {
+        var next = quantities[i + 1];
+        var upperLimit = next == null ? null : next - 1;
+        return {
+            quantity: quantity,
+            upperLimit: upperLimit,
+            label: formatBandLabel(quantity, upperLimit),
+        };
+    });
+}
+/**
+ * Quantity-break price table for the current selection.
+ *
+ * Columns are unique quantity thresholds from every discount group on the
+ * product, fields, and options. Each cell is `estimateQuote` at that quantity
+ * so the table matches what the form will charge. Returns null when there are
+ * fewer than two distinct prices (nothing useful to show).
+ */
+export function buildPriceMatrix(rules, selections, options) {
+    var e_5, _a, e_6, _b;
+    if (selections === void 0) { selections = { fieldValues: {} }; }
+    if (options === void 0) { options = {}; }
+    if (rules.unsupported)
+        return null;
+    var safeRules = __assign(__assign({}, rules), { fields: (rules.fields || []).map(function (item) { return (__assign(__assign({}, item), { options: item.options || [] })); }), groupFields: (rules.groupFields || []).map(function (item) { return (__assign(__assign({}, item), { options: item.options || [] })); }) });
+    var minQuantity = floorMinQuantity(options.minQuantity);
+    var quantities = collectQuantityBreaks(safeRules, minQuantity);
+    var quoted = [];
+    try {
+        for (var quantities_1 = __values(quantities), quantities_1_1 = quantities_1.next(); !quantities_1_1.done; quantities_1_1 = quantities_1.next()) {
+            var quantity = quantities_1_1.value;
+            var quote = estimateQuote(safeRules, selectionsAtQuantity(selections, quantity));
+            quoted.push({
+                quantity: quantity,
+                costPerUnit: quote.costPerUnit,
+                unitPrice: quote.cost / quantity,
+                cost: quote.cost,
+                taxAmount: quote.taxAmount,
+                totalCost: quote.totalCost,
+            });
+        }
+    }
+    catch (e_5_1) { e_5 = { error: e_5_1 }; }
+    finally {
+        try {
+            if (quantities_1_1 && !quantities_1_1.done && (_a = quantities_1.return)) _a.call(quantities_1);
+        }
+        finally { if (e_5) throw e_5.error; }
+    }
+    var cells = [];
+    try {
+        for (var quoted_1 = __values(quoted), quoted_1_1 = quoted_1.next(); !quoted_1_1.done; quoted_1_1 = quoted_1.next()) {
+            var cell = quoted_1_1.value;
+            var prev = cells[cells.length - 1];
+            if (prev && samePrice(prev, cell))
+                continue;
+            cells.push(cell);
+        }
+    }
+    catch (e_6_1) { e_6 = { error: e_6_1 }; }
+    finally {
+        try {
+            if (quoted_1_1 && !quoted_1_1.done && (_b = quoted_1.return)) _b.call(quoted_1);
+        }
+        finally { if (e_6) throw e_6.error; }
+    }
+    if (cells.length < 2)
+        return null;
+    return {
+        currency: rules.currency,
+        taxPercent: rules.taxPercent,
+        bands: withBandBounds(cells.map(function (cell) { return cell.quantity; })),
+        cells: cells,
+    };
+}