@merchi/sdk 1.40.2

package/dist/pricing/estimate.js

@@ -0,0 +1,335 @@
+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 { applyDiscount } from './discount.js';
+import { roundHalfEven } from './round.js';
+import { resolveVisibleFields } from './visibility.js';
+import { FieldType } from '../constants/field_types.js';
+/** Form inputs often supply quantities as strings. Coerce before any arithmetic
+ * so `reduce((a,b)=>a+b)` cannot concatenate ("100"+"1" → "01001" → 1001). */
+function toQuantity(value) {
+    var n = Number(value);
+    return Number.isFinite(n) ? n : 0;
+}
+function parseAreaMm(value) {
+    if (value === undefined || value === null || value === '')
+        return null;
+    var parts = String(value).split(',').map(function (p) { return p.trim(); });
+    if (parts.length !== 2)
+        return null;
+    var heightMm = Number(parts[0]);
+    var widthMm = Number(parts[1]);
+    if (!Number.isFinite(heightMm) || !Number.isFinite(widthMm))
+        return null;
+    if (heightMm <= 0 || widthMm <= 0)
+        return null;
+    return { heightMm: heightMm, widthMm: widthMm };
+}
+function unitPriceAt(rules, qty) {
+    var unitPrice = applyDiscount(rules.product.unitPrice, qty, rules.product.discountGroup);
+    var mop = rules.product.minimumPrice;
+    if (qty > 0 && mop && unitPrice * qty < mop) {
+        unitPrice = mop / qty;
+    }
+    return unitPrice;
+}
+function variationSetupCost(source, totalQty) {
+    var cost = source.variationCost;
+    if (source.variationCostDiscountGroup) {
+        cost = applyDiscount(cost, totalQty, source.variationCostDiscountGroup);
+    }
+    return roundHalfEven(cost, 3);
+}
+function variationUnitCosts(source, groupQuantities) {
+    var uc = source.variationUnitCost;
+    var group = source.variationUnitCostDiscountGroup;
+    var list;
+    if (group) {
+        if (group.groupRestricted) {
+            list = groupQuantities.map(function (q) { return applyDiscount(uc, q, group); });
+        }
+        else {
+            var total = groupQuantities.reduce(function (a, b) { return a + b; }, 0);
+            var discounted_1 = applyDiscount(uc, total, group);
+            list = groupQuantities.map(function () { return discounted_1; });
+        }
+    }
+    else {
+        list = groupQuantities.map(function () { return uc; });
+    }
+    return list.map(function (c) { return roundHalfEven(c, 3); });
+}
+function isEmpty(field, sel) {
+    if (!sel)
+        return true;
+    if (field.isSelectable) {
+        return !sel.selectedOptionIds || sel.selectedOptionIds.length === 0;
+    }
+    // Server `is_empty` non-selectable branch is `return not self.value`, so
+    // numeric 0 is empty (but string '0' stays non-empty, since `not '0'` is False).
+    return (sel.value === undefined ||
+        sel.value === null ||
+        sel.value === '' ||
+        sel.value === 0);
+}
+function areaCostFactor(field, sel, groupQuantities) {
+    var _a, _b, _c, _d, _e;
+    var n = groupQuantities.length;
+    var parsed = parseAreaMm((_a = sel === null || sel === void 0 ? void 0 : sel.value) !== null && _a !== void 0 ? _a : null);
+    if (!parsed) {
+        return { setup: 0, unitList: new Array(n).fill(0) };
+    }
+    var totalQty = groupQuantities.reduce(function (a, b) { return a + b; }, 0);
+    var heightSetup = variationSetupCost({
+        variationCost: field.heightVariationCost || 0,
+        variationCostDiscountGroup: (_b = field.heightVariationCostDiscountGroup) !== null && _b !== void 0 ? _b : null,
+    }, totalQty);
+    var widthSetup = variationSetupCost({
+        variationCost: field.widthVariationCost || 0,
+        variationCostDiscountGroup: (_c = field.widthVariationCostDiscountGroup) !== null && _c !== void 0 ? _c : null,
+    }, totalQty);
+    var heightUcs = variationUnitCosts({
+        variationUnitCost: field.heightVariationUnitCost || 0,
+        variationUnitCostDiscountGroup: (_d = field.heightVariationUnitCostDiscountGroup) !== null && _d !== void 0 ? _d : null,
+    }, groupQuantities);
+    var widthUcs = variationUnitCosts({
+        variationUnitCost: field.widthVariationUnitCost || 0,
+        variationUnitCostDiscountGroup: (_e = field.widthVariationUnitCostDiscountGroup) !== null && _e !== void 0 ? _e : null,
+    }, groupQuantities);
+    var areaUnit = (field.areaUnit || 'mm').toLowerCase();
+    var mmPerUnit = areaUnit === 'm' ? 1000
+        : areaUnit === 'cm' ? 10
+            : areaUnit === 'in' || areaUnit === 'inch' || areaUnit === 'inches' ? 25.4
+                : areaUnit === 'ft' || areaUnit === 'foot' || areaUnit === 'feet' ? 304.8
+                    : 1;
+    var heightU = parsed.heightMm / mmPerUnit;
+    var widthU = parsed.widthMm / mmPerUnit;
+    var area = heightU * widthU;
+    // onceOff/unit = rateH × rateW × height_u × width_u (in field areaUnit)
+    var setup = roundHalfEven(heightSetup * widthSetup * area, 3);
+    var unitList = heightUcs.map(function (hu, i) {
+        return roundHalfEven(hu * widthUcs[i] * area, 3);
+    });
+    return { setup: setup, unitList: unitList };
+}
+function costFactor(field, sel, groupQuantities) {
+    var e_1, _a, e_2, _b;
+    var n = groupQuantities.length;
+    // Coerce: JSON/APIs occasionally deliver fieldType as a string.
+    if (Number(field.fieldType) === FieldType.AREA) {
+        return areaCostFactor(field, sel, groupQuantities);
+    }
+    if (isEmpty(field, sel)) {
+        return { setup: 0, unitList: new Array(n).fill(0) };
+    }
+    var totalQty = groupQuantities.reduce(function (a, b) { return a + b; }, 0);
+    if (field.isSelectable) {
+        var setup = 0;
+        var unitList = new Array(n).fill(0);
+        var optById = new Map();
+        try {
+            for (var _c = __values(field.options), _d = _c.next(); !_d.done; _d = _c.next()) {
+                var o = _d.value;
+                optById.set(o.id, o);
+                if (o.originalId != null)
+                    optById.set(o.originalId, o);
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_d && !_d.done && (_a = _c.return)) _a.call(_c);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        try {
+            for (var _e = __values(sel.selectedOptionIds), _f = _e.next(); !_f.done; _f = _e.next()) {
+                var optId = _f.value;
+                var opt = optById.get(optId);
+                if (!opt)
+                    continue;
+                setup += variationSetupCost(opt, totalQty);
+                var ucs = variationUnitCosts(opt, groupQuantities);
+                for (var i = 0; i < n; i++)
+                    unitList[i] += ucs[i];
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (_f && !_f.done && (_b = _e.return)) _b.call(_e);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+        return { setup: setup, unitList: unitList };
+    }
+    return {
+        setup: variationSetupCost(field, totalQty),
+        unitList: variationUnitCosts(field, groupQuantities),
+    };
+}
+export function estimateQuote(rules, selections) {
+    var e_3, _a, e_4, _b, e_5, _c;
+    var _d;
+    if (rules.unsupported) {
+        return { unsupported: rules.unsupported };
+    }
+    var groupCosts = [];
+    var cost = 0;
+    var costPerUnit;
+    var groupQuantities;
+    // Mirror the server's `update_group_variations_cost_and_job_cost`
+    // (jobs.py ~3321): the group-vs-single branch keys off whether the *job*
+    // actually has variation groups (`if self.variations_groups:`), NOT the
+    // product's `hasGroups` capability. A group-capable product with no groups
+    // submitted is priced as a single non-group job (the server's `else` branch
+    // sets `group_quantities = [self.quantity or 0]`).
+    var groups = selections.groups || [];
+    if (groups.length > 0) {
+        groupQuantities = groups.map(function (g) { return toQuantity(g.quantity); });
+        var totalQty = groupQuantities.reduce(function (a, b) { return a + b; }, 0);
+        var restricted = Boolean((_d = rules.product.discountGroup) === null || _d === void 0 ? void 0 : _d.groupRestricted);
+        var baseUnitPrice = unitPriceAt(rules, totalQty);
+        var perGroupCpu = [];
+        for (var gi = 0; gi < groups.length; gi++) {
+            var group = groups[gi];
+            var gQty = groupQuantities[gi];
+            var cpu = restricted ? unitPriceAt(rules, gQty) : baseUnitPrice;
+            perGroupCpu.push(cpu);
+            // Server `VariationsGroups.update_cost` (variations_groups.py ~238):
+            // `if not self.quantity: self.group_cost = 0; return` — a zero-qty group
+            // contributes exactly 0 and adds NO field/variation costs.
+            if (!gQty) {
+                groupCosts.push(0);
+                continue;
+            }
+            // A group's field visibility is scoped to that group's own selections
+            // plus the job-level (independent) selections — NOT other groups'
+            // (server `VariationsGroups.selected_options` = group.variations +
+            // job.variations, variations_groups.py ~252).
+            var groupVisible = resolveVisibleFields(rules, {
+                fieldValues: selections.fieldValues,
+                groups: [group],
+            });
+            var groupVariationCost = 0;
+            try {
+                for (var _e = (e_3 = void 0, __values(rules.groupFields)), _f = _e.next(); !_f.done; _f = _e.next()) {
+                    var field = _f.value;
+                    if (!groupVisible.has(field.id))
+                        continue;
+                    var _g = costFactor(field, group.fieldValues[field.id], [gQty]), setup = _g.setup, unitList = _g.unitList;
+                    groupVariationCost += setup + unitList[0] * gQty;
+                }
+            }
+            catch (e_3_1) { e_3 = { error: e_3_1 }; }
+            finally {
+                try {
+                    if (_f && !_f.done && (_a = _e.return)) _a.call(_e);
+                }
+                finally { if (e_3) throw e_3.error; }
+            }
+            var groupCost = gQty * cpu + groupVariationCost;
+            groupCosts.push(groupCost);
+            cost += groupCost;
+        }
+        costPerUnit = totalQty > 0
+            ? perGroupCpu.reduce(function (acc, cpu, i) { return acc + cpu * groupQuantities[i]; }, 0) / totalQty
+            : baseUnitPrice;
+        // Independent (job-level) field visibility is scoped to independent
+        // selections only (server `Jobs.selected_options` = job.variations,
+        // jobs.py ~1392), so other groups' selections never reveal them.
+        var independentVisible = resolveVisibleFields(rules, {
+            quantity: selections.quantity,
+            fieldValues: selections.fieldValues,
+        });
+        try {
+            for (var _h = __values(rules.fields), _j = _h.next(); !_j.done; _j = _h.next()) {
+                var field = _j.value;
+                if (!independentVisible.has(field.id))
+                    continue;
+                var _k = costFactor(field, selections.fieldValues[field.id], groupQuantities), setup = _k.setup, unitList = _k.unitList;
+                var unitTotal = unitList.reduce(function (acc, uc, i) { return acc + uc * groupQuantities[i]; }, 0);
+                cost += setup + unitTotal;
+            }
+        }
+        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+        finally {
+            try {
+                if (_j && !_j.done && (_b = _h.return)) _b.call(_h);
+            }
+            finally { if (e_4) throw e_4.error; }
+        }
+    }
+    else {
+        var qty = toQuantity(selections.quantity);
+        groupQuantities = [qty];
+        costPerUnit = unitPriceAt(rules, qty);
+        cost = costPerUnit * qty;
+        // No groups: single-job scope (resolveVisibleFields with no groups uses
+        // only the top-level selections and considers only independent fields).
+        var visible = resolveVisibleFields(rules, selections);
+        try {
+            for (var _l = __values(rules.fields), _m = _l.next(); !_m.done; _m = _l.next()) {
+                var field = _m.value;
+                if (!visible.has(field.id))
+                    continue;
+                var _o = costFactor(field, selections.fieldValues[field.id], groupQuantities), setup = _o.setup, unitList = _o.unitList;
+                cost += setup + unitList[0] * qty;
+            }
+        }
+        catch (e_5_1) { e_5 = { error: e_5_1 }; }
+        finally {
+            try {
+                if (_m && !_m.done && (_c = _l.return)) _c.call(_l);
+            }
+            finally { if (e_5) throw e_5.error; }
+        }
+    }
+    // Server `Jobs.apply_product_setup_price`: product setup fee once per job,
+    // or once per non-empty group when setupPerGroup is true. With no groups the
+    // job is a single group, so setup is charged once either way.
+    var setupPrice = rules.product.setupPrice || 0;
+    if (setupPrice) {
+        if (groups.length > 0 && rules.product.setupPerGroup) {
+            for (var gi = 0; gi < groups.length; gi++) {
+                if (!groupQuantities[gi])
+                    continue;
+                groupCosts[gi] += setupPrice;
+                cost += setupPrice;
+            }
+        }
+        else {
+            cost += setupPrice;
+        }
+    }
+    // Server `Jobs.update_cost` (jobs.py ~3452-3454) accumulates `self.cost` at
+    // full precision and computes `self.tax_amount = tax(self.cost, ...)` on the
+    // UNROUNDED cost (money_protocol.py `tax` does NOT round). `cost` and
+    // `taxAmount` are then rounded INDEPENDENTLY at serialization to 2dp
+    // (jobs.py ~2169-2171). So tax must be derived from the unrounded cost.
+    var unroundedCost = cost;
+    var roundedCost = roundHalfEven(unroundedCost, 2);
+    var unroundedTax = (unroundedCost * rules.taxPercent) / 100;
+    var taxAmount = roundHalfEven(unroundedTax, 2);
+    return {
+        costPerUnit: roundHalfEven(costPerUnit, 3),
+        cost: roundedCost,
+        taxAmount: taxAmount,
+        // `totalCost` mirrors `Jobs.all_total_cost` = `self.cost + self.tax_amount`
+        // (jobs.py ~1724), serialized UNROUNDED at jobs.py ~1899. We round to 3dp to
+        // strip float noise while matching the server's effective Numeric scale.
+        totalCost: roundHalfEven(unroundedCost + unroundedTax, 3),
+        // `result["groupCost"] = self.group_cost` is serialized UNROUNDED
+        // (variations_groups.py ~154); round to 3dp to match the Numeric scale.
+        groupCosts: groupCosts.map(function (c) { return roundHalfEven(c, 3); }),
+        currency: rules.currency,
+    };
+}