@merchi/sdk 1.40.2

package/dist/pricing/matrix.test.js

@@ -0,0 +1,437 @@
+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 { buildPriceMatrix } from './matrix.js';
+function field(partial) {
+    return __assign({ originalId: partial.id, position: 0, fieldType: 2, independent: true, isSelectable: true, selectedBy: [], variationCost: 0, variationUnitCost: 0, variationCostDiscountGroup: null, variationUnitCostDiscountGroup: null, options: [] }, partial);
+}
+var base = {
+    currency: 'AUD',
+    taxPercent: 10,
+    product: { unitPrice: 10, minimumPrice: null, discountGroup: null },
+    fields: [],
+    groupFields: [],
+    hasGroups: false,
+};
+test('unsupported rules yield no matrix', function () {
+    expect(buildPriceMatrix(__assign(__assign({}, base), { unsupported: 'group_buy_product' }))).toBeNull();
+});
+test('no quantity breaks yield no matrix', function () {
+    expect(buildPriceMatrix(base, { quantity: 1, fieldValues: {} })).toBeNull();
+});
+test('product quantity breaks become columns', function () {
+    var rules = __assign(__assign({}, base), { product: {
+            unitPrice: 10,
+            minimumPrice: null,
+            discountGroup: {
+                groupRestricted: false,
+                discounts: [
+                    { lowerLimit: 100, amount: 10 },
+                    { lowerLimit: 500, amount: 20 },
+                ],
+            },
+        } });
+    var matrix = buildPriceMatrix(rules);
+    expect(matrix).toMatchObject({
+        currency: 'AUD',
+        taxPercent: 10,
+        bands: [
+            { quantity: 1, upperLimit: 99, label: '1–99' },
+            { quantity: 100, upperLimit: 499, label: '100–499' },
+            { quantity: 500, upperLimit: null, label: '500+' },
+        ],
+    });
+    expect(matrix.cells.map(function (c) { return c.costPerUnit; })).toEqual([10, 9, 8]);
+    expect(matrix.cells[0].unitPrice).toBe(10);
+    expect(matrix.cells[1].cost).toBe(900);
+    expect(matrix.cells[1].taxAmount).toBe(90);
+    expect(matrix.cells[1].totalCost).toBe(990);
+});
+test('minQuantity floors the first band and ignores lower breaks', function () {
+    var rules = __assign(__assign({}, base), { product: {
+            unitPrice: 10,
+            minimumPrice: null,
+            discountGroup: {
+                groupRestricted: false,
+                discounts: [
+                    { lowerLimit: 25, amount: 5 },
+                    { lowerLimit: 100, amount: 10 },
+                ],
+            },
+        } });
+    var matrix = buildPriceMatrix(rules, { fieldValues: {} }, { minQuantity: 50 });
+    expect(matrix.bands.map(function (b) { return b.quantity; })).toEqual([50, 100]);
+    expect(matrix.bands[0].label).toBe('50–99');
+});
+test('minQuantity below 1 is treated as 1', function () {
+    var rules = __assign(__assign({}, base), { product: {
+            unitPrice: 10,
+            minimumPrice: null,
+            discountGroup: {
+                groupRestricted: false,
+                discounts: [{ lowerLimit: 10, amount: 10 }],
+            },
+        } });
+    var matrix = buildPriceMatrix(rules, { fieldValues: {} }, { minQuantity: 0 });
+    expect(matrix.bands[0].quantity).toBe(1);
+});
+test('invalid discount limits are ignored', function () {
+    var rules = __assign(__assign({}, base), { product: {
+            unitPrice: 10,
+            minimumPrice: null,
+            discountGroup: {
+                groupRestricted: false,
+                discounts: [
+                    { lowerLimit: Number.NaN, amount: 10 },
+                    { lowerLimit: 20, amount: 10 },
+                ],
+            },
+        } });
+    expect(buildPriceMatrix(rules).bands.map(function (b) { return b.quantity; })).toEqual([1, 20]);
+});
+test('field and option discount groups contribute breaks', function () {
+    var rules = __assign(__assign({}, base), { fields: [
+            field({
+                id: 2,
+                fieldType: 5,
+                isSelectable: false,
+                variationUnitCost: 2,
+                variationUnitCostDiscountGroup: {
+                    groupRestricted: false,
+                    discounts: [{ lowerLimit: 50, amount: 50 }],
+                },
+            }),
+            field({
+                id: 1,
+                options: [
+                    {
+                        id: 101,
+                        originalId: 101,
+                        position: 0,
+                        default: true,
+                        variationCost: 20,
+                        variationUnitCost: 0,
+                        variationCostDiscountGroup: {
+                            groupRestricted: false,
+                            discounts: [{ lowerLimit: 80, amount: 50 }],
+                        },
+                        variationUnitCostDiscountGroup: null,
+                        selectedBy: [],
+                    },
+                ],
+            }),
+        ] });
+    var matrix = buildPriceMatrix(rules, {
+        quantity: 1,
+        fieldValues: {
+            1: { selectedOptionIds: [101] },
+            2: { value: 'yes' },
+        },
+    });
+    expect(matrix.bands.map(function (b) { return b.quantity; })).toEqual([1, 50, 80]);
+});
+test('area edge discount groups contribute breaks', function () {
+    var rules = __assign(__assign({}, base), { fields: [
+            field({
+                id: 14,
+                fieldType: 14,
+                isSelectable: false,
+                heightVariationCost: 2,
+                widthVariationCost: 2,
+                heightVariationUnitCost: 1,
+                widthVariationUnitCost: 1,
+                heightVariationCostDiscountGroup: {
+                    groupRestricted: false,
+                    discounts: [{ lowerLimit: 12, amount: 10 }],
+                },
+                heightVariationUnitCostDiscountGroup: {
+                    groupRestricted: false,
+                    discounts: [{ lowerLimit: 13, amount: 10 }],
+                },
+                widthVariationCostDiscountGroup: {
+                    groupRestricted: false,
+                    discounts: [{ lowerLimit: 14, amount: 10 }],
+                },
+                widthVariationUnitCostDiscountGroup: {
+                    groupRestricted: false,
+                    discounts: [{ lowerLimit: 15, amount: 10 }],
+                },
+            }),
+        ] });
+    var matrix = buildPriceMatrix(rules, {
+        quantity: 1,
+        fieldValues: { 14: { value: '100,200' } },
+    });
+    expect(matrix.bands.map(function (b) { return b.quantity; })).toEqual([1, 12, 13, 14, 15]);
+});
+test('unused option breaks that do not change price are collapsed', function () {
+    var rules = __assign(__assign({}, base), { fields: [
+            field({
+                id: 1,
+                options: [
+                    {
+                        id: 101,
+                        originalId: 101,
+                        position: 0,
+                        default: false,
+                        variationCost: 0,
+                        variationUnitCost: 5,
+                        variationCostDiscountGroup: null,
+                        variationUnitCostDiscountGroup: {
+                            groupRestricted: false,
+                            discounts: [{ lowerLimit: 100, amount: 50 }],
+                        },
+                        selectedBy: [],
+                    },
+                ],
+            }),
+        ] });
+    expect(buildPriceMatrix(rules, { quantity: 1, fieldValues: {} })).toBeNull();
+});
+test('adjacent quantities use a single-number label', function () {
+    var rules = __assign(__assign({}, base), { product: {
+            unitPrice: 10,
+            minimumPrice: null,
+            discountGroup: {
+                groupRestricted: false,
+                discounts: [{ lowerLimit: 2, amount: 10 }],
+            },
+        } });
+    expect(buildPriceMatrix(rules).bands[0]).toMatchObject({
+        quantity: 1,
+        upperLimit: 1,
+        label: '1',
+    });
+});
+test('empty discount groups and missing field arrays are skipped', function () {
+    var rules = __assign(__assign({}, base), { product: {
+            unitPrice: 10,
+            minimumPrice: null,
+            discountGroup: { groupRestricted: false, discounts: [] },
+        }, fields: undefined, groupFields: undefined });
+    expect(buildPriceMatrix(rules)).toBeNull();
+});
+test('null discount group on a field is skipped', function () {
+    var rules = __assign(__assign({}, base), { fields: [
+            field({
+                id: 1,
+                options: undefined,
+                variationCostDiscountGroup: { groupRestricted: false },
+            }),
+        ], product: {
+            unitPrice: 10,
+            minimumPrice: null,
+            discountGroup: {
+                groupRestricted: false,
+                discounts: [{ lowerLimit: 25, amount: 10 }],
+            },
+        } });
+    expect(buildPriceMatrix(rules).bands.map(function (b) { return b.quantity; })).toEqual([1, 25]);
+});
+test('group products scale the current mix to each band', function () {
+    var rules = __assign(__assign({}, base), { hasGroups: true, product: {
+            unitPrice: 10,
+            minimumPrice: null,
+            discountGroup: {
+                groupRestricted: false,
+                discounts: [{ lowerLimit: 100, amount: 10 }],
+            },
+        }, groupFields: [
+            field({
+                id: 4,
+                independent: false,
+                options: [
+                    {
+                        id: 201,
+                        originalId: 201,
+                        position: 0,
+                        default: false,
+                        variationCost: 0,
+                        variationUnitCost: 1,
+                        variationCostDiscountGroup: null,
+                        variationUnitCostDiscountGroup: null,
+                        selectedBy: [],
+                    },
+                ],
+            }),
+        ] });
+    var matrix = buildPriceMatrix(rules, {
+        fieldValues: {},
+        groups: [
+            { quantity: 10, fieldValues: { 4: { selectedOptionIds: [201] } } },
+            { quantity: 10, fieldValues: {} },
+        ],
+    });
+    expect(matrix.cells[1].quantity).toBe(100);
+    expect(matrix.cells[1].cost).toBe(950);
+});
+test('empty group quantities use the group that has values', function () {
+    var rules = __assign(__assign({}, base), { hasGroups: true, product: {
+            unitPrice: 10,
+            minimumPrice: null,
+            discountGroup: {
+                groupRestricted: false,
+                discounts: [{ lowerLimit: 20, amount: 10 }],
+            },
+        }, groupFields: [
+            field({
+                id: 4,
+                independent: false,
+                options: [
+                    {
+                        id: 201,
+                        originalId: 201,
+                        position: 0,
+                        default: false,
+                        variationCost: 0,
+                        variationUnitCost: 2,
+                        variationCostDiscountGroup: null,
+                        variationUnitCostDiscountGroup: null,
+                        selectedBy: [],
+                    },
+                ],
+            }),
+        ] });
+    var matrix = buildPriceMatrix(rules, {
+        fieldValues: {},
+        groups: [
+            { quantity: 0, fieldValues: {} },
+            { quantity: 0, fieldValues: { 4: { selectedOptionIds: [201] } } },
+        ],
+    });
+    expect(matrix.cells[0].unitPrice).toBe(12);
+});
+test('empty group values fall back to the first group', function () {
+    var rules = __assign(__assign({}, base), { hasGroups: true, product: {
+            unitPrice: 10,
+            minimumPrice: null,
+            discountGroup: {
+                groupRestricted: false,
+                discounts: [{ lowerLimit: 20, amount: 10 }],
+            },
+        } });
+    var matrix = buildPriceMatrix(rules, {
+        fieldValues: {},
+        groups: [
+            { quantity: 0, fieldValues: { 1: { selectedOptionIds: [] }, 3: undefined } },
+            { quantity: 0, fieldValues: { 2: { value: 0 } } },
+        ],
+    });
+    expect(matrix.cells[0].costPerUnit).toBe(10);
+});
+test('single group receives the full band quantity', function () {
+    var rules = __assign(__assign({}, base), { hasGroups: true, product: {
+            unitPrice: 10,
+            minimumPrice: null,
+            discountGroup: {
+                groupRestricted: false,
+                discounts: [{ lowerLimit: 10, amount: 10 }],
+            },
+        } });
+    var matrix = buildPriceMatrix(rules, {
+        fieldValues: {},
+        groups: [{ quantity: 4, fieldValues: { 9: { value: 'logo' } } }],
+    });
+    expect(matrix.cells[1].cost).toBe(90);
+});
+test('scaled groups never assign a negative remainder', function () {
+    var rules = __assign(__assign({}, base), { hasGroups: true, product: {
+            unitPrice: 10,
+            minimumPrice: null,
+            discountGroup: {
+                groupRestricted: false,
+                discounts: [{ lowerLimit: 1, amount: 0 }, { lowerLimit: 2, amount: 10 }],
+            },
+        } });
+    var matrix = buildPriceMatrix(rules, {
+        fieldValues: {},
+        groups: [
+            { quantity: 99, fieldValues: {} },
+            { quantity: 1, fieldValues: {} },
+        ],
+    }, { minQuantity: 1 });
+    expect(matrix.cells[0].quantity).toBe(1);
+});
+test('missing fieldValues on selections defaults to empty', function () {
+    var rules = __assign(__assign({}, base), { product: {
+            unitPrice: 10,
+            minimumPrice: null,
+            discountGroup: {
+                groupRestricted: false,
+                discounts: [{ lowerLimit: 10, amount: 10 }],
+            },
+        } });
+    expect(buildPriceMatrix(rules, { groups: [{ quantity: 0, fieldValues: undefined }] }).cells[0].cost).toBe(10);
+    expect(buildPriceMatrix(rules, {
+        groups: [
+            { quantity: 3, fieldValues: {} },
+            { quantity: 3, fieldValues: {} },
+        ],
+    }).cells[0].cost).toBe(10);
+});
+test('group fields with missing options still quote', function () {
+    var rules = __assign(__assign({}, base), { hasGroups: true, groupFields: [field({ id: 4, independent: false, options: undefined })], product: {
+            unitPrice: 10,
+            minimumPrice: null,
+            discountGroup: {
+                groupRestricted: false,
+                discounts: [{ lowerLimit: 10, amount: 10 }],
+            },
+        } });
+    expect(buildPriceMatrix(rules, {
+        fieldValues: {},
+        groups: [{ quantity: 5, fieldValues: { 4: { value: 'custom' } } }],
+    }).cells[1].cost).toBe(90);
+});
+test('setup amortization keeps bands when unit price changes', function () {
+    var rules = __assign(__assign({}, base), { product: {
+            unitPrice: 10,
+            minimumPrice: null,
+            setupPrice: 50,
+            discountGroup: {
+                groupRestricted: false,
+                discounts: [{ lowerLimit: 100, amount: 0 }],
+            },
+        } });
+    var matrix = buildPriceMatrix(rules);
+    expect(matrix.cells.map(function (c) { return c.quantity; })).toEqual([1, 100]);
+    expect(matrix.cells[0].costPerUnit).toBe(10);
+    expect(matrix.cells[1].costPerUnit).toBe(10);
+});
+test('empty groups array quotes as a non-group job', function () {
+    var rules = __assign(__assign({}, base), { product: {
+            unitPrice: 10,
+            minimumPrice: null,
+            discountGroup: {
+                groupRestricted: false,
+                discounts: [{ lowerLimit: 10, amount: 10 }],
+            },
+        } });
+    expect(buildPriceMatrix(rules, { groups: [] }).cells[1].cost).toBe(90);
+});
+test('non-numeric group quantity is treated as zero', function () {
+    var rules = __assign(__assign({}, base), { hasGroups: true, product: {
+            unitPrice: 10,
+            minimumPrice: null,
+            discountGroup: {
+                groupRestricted: false,
+                discounts: [{ lowerLimit: 10, amount: 10 }],
+            },
+        } });
+    var matrix = buildPriceMatrix(rules, {
+        fieldValues: {},
+        groups: [
+            { quantity: 'nope', fieldValues: { 1: { value: null } } },
+            { quantity: undefined, fieldValues: { 2: { value: '' } } },
+        ],
+    });
+    expect(matrix.cells[0].costPerUnit).toBe(10);
+});

package/dist/pricing/round.js

@@ -0,0 +1,29 @@
+/**
+ * Round `value` to `dp` decimal places using decimal half-even (round half to
+ * even / banker's rounding) so it mirrors the server's `Decimal(round(x, n))`.
+ *
+ * This intentionally matches Python's *decimal* half-even behaviour, NOT Python
+ * float `round()` (e.g. `roundHalfEven(2.675, 2) === 2.68`, whereas float
+ * `round(2.675, 2)` yields 2.67).
+ *
+ * Targeted at the money domain: small magnitudes and `dp <= 3`. The `EPS`
+ * half-detection tolerance is tuned for that domain and is not intended for
+ * arbitrary large magnitudes or high precision.
+ */
+export function roundHalfEven(value, dp) {
+    if (!isFinite(value))
+        return value;
+    var factor = Math.pow(10, dp);
+    var scaled = value * factor;
+    var floor = Math.floor(scaled);
+    var diff = scaled - floor;
+    var EPS = 1e-9;
+    var rounded;
+    if (Math.abs(diff - 0.5) < EPS) {
+        rounded = floor % 2 === 0 ? floor : floor + 1;
+    }
+    else {
+        rounded = Math.round(scaled);
+    }
+    return rounded / factor;
+}

package/dist/pricing/round.test.js

@@ -0,0 +1,27 @@
+import { roundHalfEven } from './round.js';
+test('rounds half to even like Python round()', function () {
+    expect(roundHalfEven(0.5, 0)).toBe(0);
+    expect(roundHalfEven(1.5, 0)).toBe(2);
+    expect(roundHalfEven(2.5, 0)).toBe(2);
+    expect(roundHalfEven(1.005, 2)).toBe(1.0);
+    expect(roundHalfEven(-2.5, 0)).toBe(-2);
+    expect(roundHalfEven(12.3456, 3)).toBe(12.346);
+});
+test('returns non-finite inputs unchanged', function () {
+    expect(roundHalfEven(Infinity, 2)).toBe(Infinity);
+    expect(Number.isNaN(roundHalfEven(NaN, 2))).toBe(true);
+});
+test('non-halfway values use normal rounding', function () {
+    expect(roundHalfEven(2.34, 1)).toBe(2.3);
+    expect(roundHalfEven(2.36, 1)).toBe(2.4);
+});
+test('pins decimal half-even (not float round) semantics', function () {
+    // Decimal half-even rounds the .5 tie to the even neighbour. Float
+    // round(2.675, 2) would give 2.67; decimal half-even gives 2.68.
+    expect(roundHalfEven(2.675, 2)).toBe(2.68);
+    expect(roundHalfEven(1.255, 2)).toBe(1.26);
+    // Tie rounds to the even (lower) neighbour, leaving it at the floor.
+    expect(roundHalfEven(8.245, 2)).toBe(8.24);
+    // dp=0 large value, non-tie -> normal rounding.
+    expect(roundHalfEven(100.4, 0)).toBe(100);
+});

package/dist/pricing/types.js

@@ -0,0 +1 @@
+export {};