@merchi/sdk 1.40.2

package/dist/pricing/estimate.test.js

@@ -0,0 +1,403 @@
+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);
+};
+import { estimateQuote } from './estimate.js';
+var base = {
+    currency: 'AUD', taxPercent: 10,
+    product: { unitPrice: 10, minimumPrice: null, discountGroup: null },
+    fields: [], groupFields: [], hasGroups: false,
+};
+test('returns unsupported when rules flag it', function () {
+    var r = estimateQuote(__assign(__assign({}, base), { unsupported: 'group_buy_product' }), { quantity: 5, fieldValues: {} });
+    expect(r).toEqual({ unsupported: 'group_buy_product' });
+});
+test('simple linear price + tax', function () {
+    var r = estimateQuote(base, { quantity: 5, fieldValues: {} });
+    expect(r.cost).toBe(50);
+    expect(r.taxAmount).toBe(5);
+    expect(r.totalCost).toBe(55);
+    expect(r.costPerUnit).toBe(10);
+    expect(r.currency).toBe('AUD');
+});
+test('minimum price floor raises unit price', function () {
+    var rules = __assign(__assign({}, base), { product: { unitPrice: 10, minimumPrice: 80, discountGroup: null } });
+    var r = estimateQuote(rules, { quantity: 5, fieldValues: {} });
+    expect(r.cost).toBe(80);
+});
+test('quantity-break discount applied', function () {
+    var rules = __assign(__assign({}, base), { product: {
+            unitPrice: 10, minimumPrice: null,
+            discountGroup: { groupRestricted: false, discounts: [{ lowerLimit: 100, amount: 10 }] },
+        } });
+    var r = estimateQuote(rules, { quantity: 100, fieldValues: {} });
+    expect(r.cost).toBe(900);
+});
+test('selectable field option setup + unit cost', function () {
+    var rules = __assign(__assign({}, base), { fields: [{
+                id: 1, originalId: 1, position: 0, fieldType: 2, independent: true,
+                isSelectable: true, selectedBy: [],
+                variationCost: 0, variationUnitCost: 0,
+                variationCostDiscountGroup: null, variationUnitCostDiscountGroup: null,
+                options: [{
+                        id: 101, originalId: 101, position: 0, default: false,
+                        variationCost: 5, variationUnitCost: 0.5,
+                        variationCostDiscountGroup: null, variationUnitCostDiscountGroup: null,
+                        selectedBy: [],
+                    }],
+            }] });
+    var r = estimateQuote(rules, { quantity: 10, fieldValues: { 1: { selectedOptionIds: [101] } } });
+    expect(r.cost).toBe(110); // 10*10 + 5 + 0.5*10
+});
+test('hidden conditional field is not costed', function () {
+    var rules = __assign(__assign({}, base), { fields: [{
+                id: 2, originalId: 2, position: 0, fieldType: 2, independent: true,
+                isSelectable: true, selectedBy: [999],
+                variationCost: 0, variationUnitCost: 0,
+                variationCostDiscountGroup: null, variationUnitCostDiscountGroup: null,
+                options: [{
+                        id: 201, originalId: 201, position: 0, default: false,
+                        variationCost: 7, variationUnitCost: 0,
+                        variationCostDiscountGroup: null, variationUnitCostDiscountGroup: null,
+                        selectedBy: [],
+                    }],
+            }] });
+    var r = estimateQuote(rules, { quantity: 10, fieldValues: { 2: { selectedOptionIds: [201] } } });
+    expect(r.cost).toBe(100);
+});
+test('area field multiplies height/width rate cards when dimensions set', function () {
+    var rules = __assign(__assign({}, base), { product: { unitPrice: 1, minimumPrice: null, discountGroup: null }, fields: [{
+                id: 14, originalId: 14, position: 0, fieldType: 14, independent: true,
+                isSelectable: false, selectedBy: [],
+                variationCost: 0, variationUnitCost: 0,
+                variationCostDiscountGroup: null, variationUnitCostDiscountGroup: null,
+                areaUnit: 'mm',
+                heightVariationCost: 2, widthVariationCost: 2,
+                heightVariationUnitCost: 3, widthVariationUnitCost: 4,
+                heightVariationCostDiscountGroup: null,
+                heightVariationUnitCostDiscountGroup: null,
+                widthVariationCostDiscountGroup: null,
+                widthVariationUnitCostDiscountGroup: null,
+                options: [],
+            }] });
+    var empty = estimateQuote(rules, {
+        quantity: 1, fieldValues: { 14: { value: '' } },
+    });
+    expect(empty.cost).toBe(1);
+    var priced = estimateQuote(rules, {
+        quantity: 1, fieldValues: { 14: { value: '2,5' } },
+    });
+    // area 2*5=10; onceOff 2*2*10=40; unit 3*4*10=120 → cost = 1 + 40 + 120 = 161
+    expect(priced.cost).toBe(161);
+    expect(priced.totalCost).toBe(177.1); // +10% tax
+    // String fieldType (some JSON paths) must still hit the area calculator.
+    var asString = estimateQuote(__assign(__assign({}, rules), { fields: [__assign(__assign({}, rules.fields[0]), { fieldType: '14' })] }), { quantity: 1, fieldValues: { 14: { value: '2,5' } } });
+    expect(asString.cost).toBe(161);
+});
+test('non-selectable field with value adds field cost; empty adds nothing', function () {
+    var mk = function (sel) {
+        var rules = __assign(__assign({}, base), { fields: [{
+                    id: 3, originalId: 3, position: 0, fieldType: 5, independent: true,
+                    isSelectable: false, selectedBy: [],
+                    variationCost: 4, variationUnitCost: 0,
+                    variationCostDiscountGroup: null, variationUnitCostDiscountGroup: null,
+                    options: [],
+                }] });
+        return estimateQuote(rules, { quantity: 10, fieldValues: { 3: sel } });
+    };
+    expect(mk({ value: 'hello' }).cost).toBe(104);
+    expect(mk({ value: '' }).cost).toBe(100);
+    expect(mk(undefined).cost).toBe(100);
+    // Server `is_empty` uses `not self.value`: numeric 0 is empty, string '0' is not.
+    expect(mk({ value: 0 }).cost).toBe(100);
+    expect(mk({ value: '0' }).cost).toBe(104);
+});
+test('tax computed from unrounded cost, not rounded cost (non-10% rate)', function () {
+    var rules = __assign(__assign({}, base), { taxPercent: 33, fields: [{
+                id: 7, originalId: 7, position: 0, fieldType: 5, independent: true,
+                isSelectable: false, selectedBy: [],
+                variationCost: 0.075, variationUnitCost: 0,
+                variationCostDiscountGroup: null, variationUnitCostDiscountGroup: null,
+                options: [],
+            }] });
+    var r = estimateQuote(rules, { quantity: 10, fieldValues: { 7: { value: 'x' } } });
+    // unrounded cost = 100 + 0.075 = 100.075
+    expect(r.cost).toBe(100.08); // roundHalfEven(100.075, 2)
+    // tax from UNROUNDED: round(100.075*0.33, 2) = round(33.02475, 2) = 33.02
+    // (the buggy round(round(100.075,2)*0.33,2) would give 33.03)
+    expect(r.taxAmount).toBe(33.02);
+    expect(r.totalCost).toBe(133.1); // round(100.075 + 33.02475, 3)
+});
+test('zero-qty group adds no field cost even when a visible field has value', function () {
+    var rules = __assign(__assign({}, base), { hasGroups: true, groupFields: [
+            {
+                id: 50, originalId: 50, position: 0, fieldType: 5, independent: false,
+                isSelectable: false, selectedBy: [],
+                variationCost: 20, variationUnitCost: 0,
+                variationCostDiscountGroup: null, variationUnitCostDiscountGroup: null,
+                options: [],
+            },
+            {
+                // hidden conditional group field: skipped in the non-zero-qty group too
+                id: 51, originalId: 51, position: 1, fieldType: 5, independent: false,
+                isSelectable: false, selectedBy: [888],
+                variationCost: 99, variationUnitCost: 0,
+                variationCostDiscountGroup: null, variationUnitCostDiscountGroup: null,
+                options: [],
+            },
+        ] });
+    var r = estimateQuote(rules, {
+        fieldValues: {},
+        groups: [
+            { quantity: 0, fieldValues: { 50: { value: 'present' } } },
+            { quantity: 5, fieldValues: {} },
+        ],
+    });
+    // zero-qty group contributes exactly 0 (no +20 setup); other group: 5*10 = 50
+    expect(r.groupCosts).toEqual([0, 50]);
+    expect(r.cost).toBe(50);
+});
+test('groupCost preserves 3rd-decimal precision', function () {
+    var rules = __assign(__assign({}, base), { hasGroups: true, groupFields: [{
+                id: 60, originalId: 60, position: 0, fieldType: 5, independent: false,
+                isSelectable: false, selectedBy: [],
+                variationCost: 0, variationUnitCost: 0.001,
+                variationCostDiscountGroup: null, variationUnitCostDiscountGroup: null,
+                options: [],
+            }] });
+    var r = estimateQuote(rules, {
+        fieldValues: {},
+        groups: [{ quantity: 3, fieldValues: { 60: { value: 'x' } } }],
+    });
+    // groupCost = 3*10 + 0.001*3 = 30.003, serialized at 3dp (not 2dp)
+    expect(r.groupCosts).toEqual([30.003]);
+});
+test('group product: weighted unit price and summed group costs', function () {
+    var rules = __assign(__assign({}, base), { hasGroups: true });
+    var r = estimateQuote(rules, {
+        fieldValues: {},
+        groups: [{ quantity: 3, fieldValues: {} }, { quantity: 7, fieldValues: {} }],
+    });
+    expect(r.cost).toBe(100);
+    expect(r.groupCosts).toEqual([30, 70]);
+    expect(r.costPerUnit).toBe(10);
+});
+test('product setupPrice applied once to job', function () {
+    var rules = __assign(__assign({}, base), { product: {
+            unitPrice: 10, minimumPrice: null, setupPrice: 25,
+            setupPerGroup: false, discountGroup: null,
+        } });
+    var r = estimateQuote(rules, { quantity: 5, fieldValues: {} });
+    expect(r.cost).toBe(75);
+    expect(r.taxAmount).toBe(7.5);
+});
+test('product setupPrice applied once across groups when setupPerGroup is false', function () {
+    var rules = __assign(__assign({}, base), { hasGroups: true, product: {
+            unitPrice: 10, minimumPrice: null, setupPrice: 25,
+            setupPerGroup: false, discountGroup: null,
+        } });
+    var r = estimateQuote(rules, {
+        fieldValues: {},
+        groups: [{ quantity: 3, fieldValues: {} }, { quantity: 7, fieldValues: {} }],
+    });
+    expect(r.groupCosts).toEqual([30, 70]);
+    expect(r.cost).toBe(125);
+});
+test('product setupPrice applied per non-empty group when setupPerGroup is true', function () {
+    var rules = __assign(__assign({}, base), { hasGroups: true, product: {
+            unitPrice: 10, minimumPrice: null, setupPrice: 25,
+            setupPerGroup: true, discountGroup: null,
+        } });
+    var r = estimateQuote(rules, {
+        fieldValues: {},
+        groups: [
+            { quantity: 3, fieldValues: {} },
+            { quantity: 0, fieldValues: {} },
+            { quantity: 7, fieldValues: {} },
+        ],
+    });
+    expect(r.groupCosts).toEqual([55, 0, 95]);
+    expect(r.cost).toBe(150);
+});
+test('group quantities from form inputs are numeric strings and must not concatenate', function () {
+    var rules = __assign(__assign({}, base), { hasGroups: true, product: {
+            unitPrice: 10,
+            minimumPrice: null,
+            discountGroup: {
+                groupRestricted: false,
+                discounts: [{ lowerLimit: 1000, amount: 50 }],
+            },
+        } });
+    var r = estimateQuote(rules, {
+        fieldValues: {},
+        groups: [
+            { quantity: '100', fieldValues: {} },
+            { quantity: '1', fieldValues: {} },
+        ],
+    });
+    // 100+1=101, below the 1000-unit break. String concat would yield "01001"→1001
+    // and incorrectly apply the 50% discount.
+    expect(r.groupCosts).toEqual([1000, 10]);
+    expect(r.cost).toBe(1010);
+    expect(r.costPerUnit).toBe(10);
+});
+test('group product with no groups array: zero cost', function () {
+    var rules = __assign(__assign({}, base), { hasGroups: true });
+    var r = estimateQuote(rules, { fieldValues: {} });
+    expect(r.cost).toBe(0);
+    expect(r.costPerUnit).toBe(10);
+});
+test('zero quantity yields zero cost and no NaN unit price', function () {
+    var r = estimateQuote(base, { quantity: 0, fieldValues: {} });
+    expect(r.cost).toBe(0);
+    expect(r.costPerUnit).toBe(10);
+});
+test('missing quantity treated as zero', function () {
+    var r = estimateQuote(base, { fieldValues: {} });
+    expect(r.cost).toBe(0);
+});
+test('option setup + unit-cost discount groups (non-restricted) applied', function () {
+    var dg = { groupRestricted: false, discounts: [{ lowerLimit: 5, amount: 50 }] };
+    var rules = __assign(__assign({}, base), { fields: [{
+                id: 1, originalId: 1, position: 0, fieldType: 2, independent: true,
+                isSelectable: true, selectedBy: [],
+                variationCost: 0, variationUnitCost: 0,
+                variationCostDiscountGroup: null, variationUnitCostDiscountGroup: null,
+                options: [{
+                        id: 101, originalId: 101, position: 0, default: false,
+                        variationCost: 10, variationUnitCost: 2,
+                        variationCostDiscountGroup: dg, variationUnitCostDiscountGroup: dg,
+                        selectedBy: [],
+                    }],
+            }] });
+    var r = estimateQuote(rules, { quantity: 10, fieldValues: { 1: { selectedOptionIds: [101] } } });
+    // setup: 10 * (1-0.5) = 5; unit: 2 * 0.5 = 1 -> 1*10 = 10; base 100
+    expect(r.cost).toBe(115);
+});
+test('unknown selectedOptionId is skipped; originalId lookup matches', function () {
+    var rules = __assign(__assign({}, base), { fields: [{
+                id: 1, originalId: 1, position: 0, fieldType: 2, independent: true,
+                isSelectable: true, selectedBy: [],
+                variationCost: 0, variationUnitCost: 0,
+                variationCostDiscountGroup: null, variationUnitCostDiscountGroup: null,
+                options: [{
+                        id: 101, originalId: 999, position: 0, default: false,
+                        variationCost: 3, variationUnitCost: 0,
+                        variationCostDiscountGroup: null, variationUnitCostDiscountGroup: null,
+                        selectedBy: [],
+                    }],
+            }] });
+    // 999 resolves via originalId (+3 setup); 555 is unknown and skipped
+    var r = estimateQuote(rules, { quantity: 10, fieldValues: { 1: { selectedOptionIds: [999, 555] } } });
+    expect(r.cost).toBe(103);
+});
+test('group product: group fields and group-restricted independent unit cost', function () {
+    var restrictedDg = { groupRestricted: true, discounts: [{ lowerLimit: 5, amount: 50 }] };
+    var rules = __assign(__assign({}, base), { hasGroups: true, groupFields: [{
+                id: 10, originalId: 10, position: 0, fieldType: 5, independent: false,
+                isSelectable: false, selectedBy: [],
+                variationCost: 4, variationUnitCost: 1,
+                variationCostDiscountGroup: null, variationUnitCostDiscountGroup: null,
+                options: [],
+            }], fields: [{
+                id: 20, originalId: 20, position: 0, fieldType: 2, independent: true,
+                isSelectable: true, selectedBy: [],
+                variationCost: 0, variationUnitCost: 0,
+                variationCostDiscountGroup: null, variationUnitCostDiscountGroup: null,
+                options: [{
+                        id: 120, originalId: 120, position: 0, default: false,
+                        variationCost: 0, variationUnitCost: 2,
+                        variationCostDiscountGroup: null, variationUnitCostDiscountGroup: restrictedDg,
+                        selectedBy: [],
+                    }],
+            }] });
+    var r = estimateQuote(rules, {
+        fieldValues: { 20: { selectedOptionIds: [120] } },
+        groups: [
+            { quantity: 3, fieldValues: { 10: { value: 'x' } } },
+            { quantity: 7, fieldValues: {} },
+        ],
+    });
+    // groups base: 3*10 + (4 + 1*3) = 30 + 7 = 37; 7*10 = 70 -> groupCosts [37,70]
+    // independent restricted unit: q3<5 -> 2, q7>=5 -> 1; total 2*3 + 1*7 = 13
+    // cost = 37 + 70 + 13 = 120
+    expect(r.groupCosts).toEqual([37, 70]);
+    expect(r.cost).toBe(120);
+    expect(r.costPerUnit).toBe(10);
+});
+test('group product: restricted product discount, zero-qty group, hidden fields skipped', function () {
+    var rules = __assign(__assign({}, base), { hasGroups: true, product: {
+            unitPrice: 10, minimumPrice: null,
+            discountGroup: { groupRestricted: true, discounts: [] },
+        }, groupFields: [{
+                id: 30, originalId: 30, position: 0, fieldType: 2, independent: false,
+                isSelectable: true, selectedBy: [888],
+                variationCost: 50, variationUnitCost: 0,
+                variationCostDiscountGroup: null, variationUnitCostDiscountGroup: null,
+                options: [],
+            }], fields: [{
+                id: 40, originalId: 40, position: 0, fieldType: 2, independent: true,
+                isSelectable: true, selectedBy: [888],
+                variationCost: 60, variationUnitCost: 0,
+                variationCostDiscountGroup: null, variationUnitCostDiscountGroup: null,
+                options: [],
+            }] });
+    var r = estimateQuote(rules, {
+        fieldValues: {},
+        groups: [{ quantity: 0, fieldValues: {} }],
+    });
+    // restricted product discount group (empty discounts -> no change); group qty 0;
+    // both conditional fields hidden (selectedBy [888] unmet) so not costed
+    expect(r.cost).toBe(0);
+    expect(r.groupCosts).toEqual([0]);
+    expect(r.costPerUnit).toBe(10);
+});
+test('group field visibility is scoped per group (no cross-group leak)', function () {
+    // Size field (24mm=801, 25mm=802) and a premium group field gated by 25mm
+    // (selectedBy [802]) whose selected option 811 costs 5 setup.
+    var opt = function (id, selectedBy) {
+        if (selectedBy === void 0) { selectedBy = []; }
+        return ({
+            id: id,
+            originalId: id, position: id, default: false,
+            variationCost: 0, variationUnitCost: 0,
+            variationCostDiscountGroup: null, variationUnitCostDiscountGroup: null,
+            selectedBy: selectedBy,
+        });
+    };
+    var rules = __assign(__assign({}, base), { hasGroups: true, product: { unitPrice: 0, minimumPrice: null, discountGroup: null }, taxPercent: 0, groupFields: [
+            {
+                id: 800, originalId: 800, position: 0, fieldType: 2, independent: false,
+                isSelectable: true, selectedBy: [],
+                variationCost: 0, variationUnitCost: 0,
+                variationCostDiscountGroup: null, variationUnitCostDiscountGroup: null,
+                options: [opt(801), opt(802)],
+            },
+            {
+                id: 810, originalId: 810, position: 1, fieldType: 2, independent: false,
+                isSelectable: true, selectedBy: [802],
+                variationCost: 0, variationUnitCost: 0,
+                variationCostDiscountGroup: null, variationUnitCostDiscountGroup: null,
+                options: [__assign(__assign({}, opt(811)), { variationCost: 5 })],
+            },
+        ] });
+    // Group A picks 24mm but ALSO has premium 811 selected; Group B picks 25mm + 811.
+    // Scoped: A's premium field is hidden (24mm) -> 811 NOT costed; B's is visible
+    // -> 811 costs 5. A global resolver would wrongly cost A's 811 too (total 10).
+    var r = estimateQuote(rules, {
+        fieldValues: {},
+        groups: [
+            { quantity: 10, fieldValues: { 800: { selectedOptionIds: [801] }, 810: { selectedOptionIds: [811] } } },
+            { quantity: 10, fieldValues: { 800: { selectedOptionIds: [802] }, 810: { selectedOptionIds: [811] } } },
+        ],
+    });
+    expect(r.groupCosts).toEqual([0, 5]);
+    expect(r.cost).toBe(5);
+});

package/dist/pricing/golden.test.js

@@ -0,0 +1,61 @@
+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));
+};
+import * as fs from 'fs';
+import * as path from 'path';
+import { estimateQuote } from './estimate.js';
+import { resolveVisibleFields } from './visibility.js';
+// Fixtures are vendored into the SDK so the golden parity test is
+// self-contained in CI. They are generated by the merchi_api fixture
+// generator (tests/tests/pricing_fixtures.py) from the real server estimate.
+var FIXTURES_DIR = path.resolve(__dirname, '__fixtures__');
+function loadFixtures() {
+    if (!fs.existsSync(FIXTURES_DIR))
+        return [];
+    return fs.readdirSync(FIXTURES_DIR)
+        .filter(function (f) { return f.endsWith('.json'); })
+        .map(function (f) { return JSON.parse(fs.readFileSync(path.join(FIXTURES_DIR, f), 'utf-8')); });
+}
+var fixtures = loadFixtures();
+test('pricing fixtures exist', function () {
+    expect(fixtures.length).toBeGreaterThan(0);
+});
+describe.each(fixtures)('golden parity: $name', function (fixture) {
+    test('estimateQuote matches server', function () {
+        var result = estimateQuote(fixture.bundle, fixture.selections);
+        expect(result.cost).toBeCloseTo(fixture.expected.cost, 2);
+        expect(result.costPerUnit).toBeCloseTo(fixture.expected.costPerUnit, 3);
+        expect(result.taxAmount).toBeCloseTo(fixture.expected.taxAmount, 2);
+        expect(result.totalCost).toBeCloseTo(fixture.expected.totalCost, 2);
+        expect(result.groupCosts.length).toBe(fixture.expected.groupCosts.length);
+        result.groupCosts.forEach(function (c, i) {
+            return expect(c).toBeCloseTo(fixture.expected.groupCosts[i], 2);
+        });
+    });
+    test('resolveVisibleFields matches server', function () {
+        var visible = __spreadArray([], __read(resolveVisibleFields(fixture.bundle, fixture.selections)), false).sort(function (a, b) { return a - b; });
+        expect(visible).toEqual(fixture.expected.visibleFieldIds);
+    });
+});

package/dist/pricing/index.js

@@ -0,0 +1,7 @@
+export * from './types.js';
+export { roundHalfEven } from './round.js';
+export { applyDiscount } from './discount.js';
+export { resolveVisibleFields, resolveVisibleOptionIds } from './visibility.js';
+export { resolveUnavailableOptionIds } from './inventory.js';
+export { estimateQuote } from './estimate.js';
+export { buildPriceMatrix } from './matrix.js';

package/dist/pricing/index.test.js

@@ -0,0 +1,8 @@
+import { pricing } from '../index.js';
+test('pricing namespace exposes calculator functions', function () {
+    expect(typeof pricing.estimateQuote).toBe('function');
+    expect(typeof pricing.buildPriceMatrix).toBe('function');
+    expect(typeof pricing.resolveVisibleFields).toBe('function');
+    expect(typeof pricing.applyDiscount).toBe('function');
+    expect(typeof pricing.roundHalfEven).toBe('function');
+});