@merchi/product-form 1.19.12

package/lib/utils/priceMatrix.js

@@ -0,0 +1,82 @@
+import { productMoqFloor } from './quantity';
+import { productHasGroups } from './products';
+function buildPriceMatrixFn() {
+  try {
+    var _ref = require('@merchi/sdk'),
+      pricing = _ref.pricing;
+    return typeof (pricing === null || pricing === void 0 ? void 0 : pricing.buildPriceMatrix) === 'function' ? pricing.buildPriceMatrix : null;
+  } catch (_unused) {
+    return null;
+  }
+}
+/** Compact pricing-rules bundle from product JSON when the live bundle is absent. */
+export function pricingRulesFromProduct(product) {
+  var _product$taxType;
+  var raw = (product === null || product === void 0 ? void 0 : product.unitPriceDiscountGroup) || (product === null || product === void 0 ? void 0 : product.discountGroup);
+  var discounts = ((raw === null || raw === void 0 ? void 0 : raw.discounts) || []).map(function (discount) {
+    return {
+      lowerLimit: Number(discount.lowerLimit),
+      amount: Number(discount.amount)
+    };
+  }).filter(function (discount) {
+    return Number.isFinite(discount.lowerLimit) && Number.isFinite(discount.amount);
+  });
+  if (!discounts.length) return null;
+  var minimumPrice = product === null || product === void 0 ? void 0 : product.minimumPrice;
+  return {
+    currency: (product === null || product === void 0 ? void 0 : product.currency) || 'AUD',
+    taxPercent: Number(product === null || product === void 0 || (_product$taxType = product.taxType) === null || _product$taxType === void 0 ? void 0 : _product$taxType.taxPercent) || 0,
+    product: {
+      unitPrice: Number(product === null || product === void 0 ? void 0 : product.unitPrice) || 0,
+      minimumPrice: minimumPrice == null || minimumPrice === '' ? null : Number(minimumPrice),
+      setupPrice: Number(product === null || product === void 0 ? void 0 : product.setupPrice) || 0,
+      setupPerGroup: Boolean(product === null || product === void 0 ? void 0 : product.setupPerGroup),
+      discountGroup: {
+        groupRestricted: Boolean(raw.groupRestricted),
+        discounts: discounts
+      }
+    },
+    fields: [],
+    groupFields: [],
+    hasGroups: false
+  };
+}
+export function resolvePricingRules(pricingRules, product) {
+  if (pricingRules && !pricingRules.unsupported) return pricingRules;
+  return pricingRulesFromProduct(product);
+}
+export function currentOrderQuantity(job, product) {
+  var hasGroups = productHasGroups(product);
+  if (hasGroups && Array.isArray(job === null || job === void 0 ? void 0 : job.variationsGroups)) {
+    return job.variationsGroups.reduce(function (sum, group) {
+      var n = Number(group === null || group === void 0 ? void 0 : group.quantity);
+      return sum + (Number.isFinite(n) ? n : 0);
+    }, 0);
+  }
+  var n = Number(job === null || job === void 0 ? void 0 : job.quantity);
+  return Number.isFinite(n) ? n : 0;
+}
+export function activeBandIndex(matrix, quantity) {
+  if (!matrix.bands.length || quantity < matrix.bands[0].quantity) return -1;
+  for (var i = matrix.bands.length - 1; i >= 0; i--) {
+    if (quantity >= matrix.bands[i].quantity) return i;
+  }
+  return -1;
+}
+/** Build or pass through a price table. No form context required. */
+export function resolvePriceMatrix() {
+  var _options$matrix;
+  var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  if ((_options$matrix = options.matrix) !== null && _options$matrix !== void 0 && (_options$matrix = _options$matrix.bands) !== null && _options$matrix !== void 0 && _options$matrix.length) return options.matrix;
+  var buildPriceMatrix = options.buildPriceMatrix || buildPriceMatrixFn();
+  if (!buildPriceMatrix) return null;
+  var rules = resolvePricingRules(options.rules, options.product);
+  if (!rules) return null;
+  var minQuantity = options.minQuantity != null ? options.minQuantity : productMoqFloor(options.product);
+  return buildPriceMatrix(rules, options.selections || {
+    fieldValues: {}
+  }, {
+    minQuantity: minQuantity
+  });
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["productMoqFloor","productHasGroups","buildPriceMatrixFn","_ref","require","pricing","buildPriceMatrix","_unused","pricingRulesFromProduct","product","_product$taxType","raw","unitPriceDiscountGroup","discountGroup","discounts","map","discount","lowerLimit","Number","amount","filter","isFinite","length","minimumPrice","currency","taxPercent","taxType","unitPrice","setupPrice","setupPerGroup","Boolean","groupRestricted","fields","groupFields","hasGroups","resolvePricingRules","pricingRules","unsupported","currentOrderQuantity","job","Array","isArray","variationsGroups","reduce","sum","group","n","quantity","activeBandIndex","matrix","bands","i","resolvePriceMatrix","_options$matrix","options","arguments","undefined","rules","minQuantity","selections","fieldValues"],"sources":["../../src/utils/priceMatrix.ts"],"sourcesContent":["import { productMoqFloor } from './quantity';\nimport { productHasGroups } from './products';\n\nfunction buildPriceMatrixFn():\n  | ((rules: any, selections?: any, options?: any) => PriceMatrixData | null)\n  | null {\n  try {\n    const { pricing } = require('@merchi/sdk') as {\n      pricing?: {\n        buildPriceMatrix?: (\n          rules: any,\n          selections?: any,\n          options?: any\n        ) => PriceMatrixData | null;\n      };\n    };\n    return typeof pricing?.buildPriceMatrix === 'function'\n      ? pricing.buildPriceMatrix\n      : null;\n  } catch {\n    return null;\n  }\n}\n\nexport interface PriceMatrixBand {\n  quantity: number;\n  upperLimit: number | null;\n  label: string;\n}\n\nexport interface PriceMatrixCell {\n  quantity: number;\n  costPerUnit: number;\n  unitPrice: number;\n  cost: number;\n  taxAmount: number;\n  totalCost: number;\n}\n\nexport interface PriceMatrixData {\n  currency: string;\n  taxPercent: number;\n  bands: PriceMatrixBand[];\n  cells: PriceMatrixCell[];\n}\n\ninterface PricingRulesLike {\n  unsupported?: string;\n  currency?: string;\n  taxPercent?: number;\n  product?: {\n    unitPrice?: number;\n    minimumPrice?: number | null;\n    setupPrice?: number;\n    setupPerGroup?: boolean;\n    discountGroup?: { groupRestricted?: boolean; discounts?: any[] } | null;\n  };\n  fields?: any[];\n  groupFields?: any[];\n  hasGroups?: boolean;\n}\n\n/** Compact pricing-rules bundle from product JSON when the live bundle is absent. */\nexport function pricingRulesFromProduct(product: any): PricingRulesLike | null {\n  const raw = product?.unitPriceDiscountGroup || product?.discountGroup;\n  const discounts = (raw?.discounts || [])\n    .map((discount: any) => ({\n      lowerLimit: Number(discount.lowerLimit),\n      amount: Number(discount.amount),\n    }))\n    .filter(\n      (discount: { lowerLimit: number; amount: number }) =>\n        Number.isFinite(discount.lowerLimit) && Number.isFinite(discount.amount)\n    );\n  if (!discounts.length) return null;\n  const minimumPrice = product?.minimumPrice;\n  return {\n    currency: product?.currency || 'AUD',\n    taxPercent: Number(product?.taxType?.taxPercent) || 0,\n    product: {\n      unitPrice: Number(product?.unitPrice) || 0,\n      minimumPrice:\n        minimumPrice == null || minimumPrice === ''\n          ? null\n          : Number(minimumPrice),\n      setupPrice: Number(product?.setupPrice) || 0,\n      setupPerGroup: Boolean(product?.setupPerGroup),\n      discountGroup: {\n        groupRestricted: Boolean(raw.groupRestricted),\n        discounts,\n      },\n    },\n    fields: [],\n    groupFields: [],\n    hasGroups: false,\n  };\n}\n\nexport function resolvePricingRules(\n  pricingRules: PricingRulesLike | null | undefined,\n  product: any\n): PricingRulesLike | null {\n  if (pricingRules && !pricingRules.unsupported) return pricingRules;\n  return pricingRulesFromProduct(product);\n}\n\nexport function currentOrderQuantity(job: any, product: any): number {\n  const hasGroups = productHasGroups(product);\n  if (hasGroups && Array.isArray(job?.variationsGroups)) {\n    return job.variationsGroups.reduce((sum: number, group: any) => {\n      const n = Number(group?.quantity);\n      return sum + (Number.isFinite(n) ? n : 0);\n    }, 0);\n  }\n  const n = Number(job?.quantity);\n  return Number.isFinite(n) ? n : 0;\n}\n\nexport function activeBandIndex(matrix: PriceMatrixData, quantity: number): number {\n  if (!matrix.bands.length || quantity < matrix.bands[0].quantity) return -1;\n  for (let i = matrix.bands.length - 1; i >= 0; i--) {\n    if (quantity >= matrix.bands[i].quantity) return i;\n  }\n  return -1;\n}\n\nexport interface ResolvePriceMatrixOptions {\n  matrix?: PriceMatrixData | null;\n  rules?: PricingRulesLike | null;\n  product?: any;\n  selections?: { quantity?: number; fieldValues?: Record<number, any>; groups?: any[] };\n  minQuantity?: number;\n  buildPriceMatrix?: (\n    rules: any,\n    selections?: any,\n    options?: any\n  ) => PriceMatrixData | null;\n}\n\n/** Build or pass through a price table. No form context required. */\nexport function resolvePriceMatrix(\n  options: ResolvePriceMatrixOptions = {}\n): PriceMatrixData | null {\n  if (options.matrix?.bands?.length) return options.matrix;\n  const buildPriceMatrix = options.buildPriceMatrix || buildPriceMatrixFn();\n  if (!buildPriceMatrix) return null;\n  const rules = resolvePricingRules(options.rules, options.product);\n  if (!rules) return null;\n  const minQuantity =\n    options.minQuantity != null\n      ? options.minQuantity\n      : productMoqFloor(options.product);\n  return buildPriceMatrix(\n    rules,\n    options.selections || { fieldValues: {} },\n    { minQuantity }\n  );\n}\n"],"mappings":"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","ignoreList":[]}

package/lib/utils/priceMatrix.test.js

@@ -0,0 +1,200 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function _defineProperty(e, r, t) { return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+import { activeBandIndex, currentOrderQuantity, pricingRulesFromProduct, resolvePriceMatrix, resolvePricingRules } from './priceMatrix';
+test('pricingRulesFromProduct maps unit-price discount groups', function () {
+  var rules = pricingRulesFromProduct({
+    currency: 'USD',
+    unitPrice: 12,
+    minimumPrice: 0,
+    setupPrice: 5,
+    setupPerGroup: true,
+    taxType: {
+      taxPercent: 10
+    },
+    unitPriceDiscountGroup: {
+      groupRestricted: true,
+      discounts: [{
+        lowerLimit: 50,
+        amount: 10
+      }, {
+        lowerLimit: 'nope',
+        amount: 5
+      }]
+    }
+  });
+  expect(rules).toMatchObject({
+    currency: 'USD',
+    taxPercent: 10,
+    product: {
+      unitPrice: 12,
+      minimumPrice: 0,
+      setupPrice: 5,
+      setupPerGroup: true,
+      discountGroup: {
+        groupRestricted: true,
+        discounts: [{
+          lowerLimit: 50,
+          amount: 10
+        }]
+      }
+    }
+  });
+});
+test('pricingRulesFromProduct falls back to discountGroup and defaults', function () {
+  expect(pricingRulesFromProduct({})).toBeNull();
+  expect(pricingRulesFromProduct({
+    discountGroup: {
+      discounts: [{
+        lowerLimit: 10,
+        amount: 5
+      }]
+    }
+  })).toMatchObject({
+    currency: 'AUD',
+    taxPercent: 0,
+    product: {
+      unitPrice: 0,
+      minimumPrice: null,
+      setupPrice: 0
+    }
+  });
+});
+test('resolvePricingRules prefers a live bundle', function () {
+  var _resolvePricingRules;
+  var live = {
+    currency: 'NZD',
+    product: {
+      unitPrice: 1
+    }
+  };
+  expect(resolvePricingRules(live, {})).toBe(live);
+  expect(resolvePricingRules({
+    unsupported: 'group_buy'
+  }, {})).toBeNull();
+  expect((_resolvePricingRules = resolvePricingRules(null, {
+    unitPriceDiscountGroup: {
+      discounts: [{
+        lowerLimit: 5,
+        amount: 1
+      }]
+    }
+  })) === null || _resolvePricingRules === void 0 ? void 0 : _resolvePricingRules.currency).toBe('AUD');
+});
+test('currentOrderQuantity sums groups or reads job.quantity', function () {
+  expect(currentOrderQuantity({
+    variationsGroups: [{
+      quantity: 4
+    }, {
+      quantity: '6'
+    }, {
+      quantity: 'x'
+    }]
+  }, {
+    groupVariationFields: [{
+      id: 1
+    }]
+  })).toBe(10);
+  expect(currentOrderQuantity({
+    quantity: 7
+  }, {})).toBe(7);
+  expect(currentOrderQuantity({}, {})).toBe(0);
+});
+test('activeBandIndex highlights the highest matching break', function () {
+  var matrix = {
+    currency: 'AUD',
+    taxPercent: 0,
+    bands: [{
+      quantity: 1,
+      upperLimit: 49,
+      label: '1–49'
+    }, {
+      quantity: 50,
+      upperLimit: null,
+      label: '50+'
+    }],
+    cells: []
+  };
+  expect(activeBandIndex(matrix, 0)).toBe(-1);
+  expect(activeBandIndex(matrix, 1)).toBe(0);
+  expect(activeBandIndex(matrix, 49)).toBe(0);
+  expect(activeBandIndex(matrix, 50)).toBe(1);
+  expect(activeBandIndex(_objectSpread(_objectSpread({}, matrix), {}, {
+    bands: []
+  }), 10)).toBe(-1);
+});
+test('resolvePriceMatrix returns a provided matrix', function () {
+  var matrix = {
+    currency: 'AUD',
+    taxPercent: 10,
+    bands: [{
+      quantity: 1,
+      upperLimit: null,
+      label: '1+'
+    }],
+    cells: []
+  };
+  expect(resolvePriceMatrix({
+    matrix: matrix
+  })).toBe(matrix);
+});
+test('resolvePriceMatrix builds from a product discount group', function () {
+  var matrix = resolvePriceMatrix({
+    product: {
+      currency: 'AUD',
+      unitPrice: 10,
+      unitPriceDiscountGroup: {
+        discounts: [{
+          lowerLimit: 100,
+          amount: 10
+        }]
+      }
+    },
+    buildPriceMatrix: function buildPriceMatrix(rules) {
+      return {
+        currency: rules.currency,
+        taxPercent: rules.taxPercent,
+        bands: [{
+          quantity: 1,
+          upperLimit: 99,
+          label: '1–99'
+        }, {
+          quantity: 100,
+          upperLimit: null,
+          label: '100+'
+        }],
+        cells: [{
+          quantity: 1,
+          costPerUnit: 10,
+          unitPrice: 10,
+          cost: 10,
+          taxAmount: 0,
+          totalCost: 10
+        }, {
+          quantity: 100,
+          costPerUnit: 9,
+          unitPrice: 9,
+          cost: 900,
+          taxAmount: 0,
+          totalCost: 900
+        }]
+      };
+    }
+  });
+  expect(matrix === null || matrix === void 0 ? void 0 : matrix.bands.map(function (band) {
+    return band.quantity;
+  })).toEqual([1, 100]);
+  expect(matrix === null || matrix === void 0 ? void 0 : matrix.cells[1].costPerUnit).toBe(9);
+});
+test('resolvePriceMatrix returns null without breaks or a matrix', function () {
+  expect(resolvePriceMatrix({
+    product: {
+      unitPrice: 10
+    }
+  })).toBeNull();
+  expect(resolvePriceMatrix({})).toBeNull();
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["activeBandIndex","currentOrderQuantity","pricingRulesFromProduct","resolvePriceMatrix","resolvePricingRules","test","rules","currency","unitPrice","minimumPrice","setupPrice","setupPerGroup","taxType","taxPercent","unitPriceDiscountGroup","groupRestricted","discounts","lowerLimit","amount","expect","toMatchObject","product","discountGroup","toBeNull","_resolvePricingRules","live","toBe","unsupported","variationsGroups","quantity","groupVariationFields","id","matrix","bands","upperLimit","label","cells","_objectSpread","buildPriceMatrix","costPerUnit","cost","taxAmount","totalCost","map","band","toEqual"],"sources":["../../src/utils/priceMatrix.test.ts"],"sourcesContent":["import {\n  activeBandIndex,\n  currentOrderQuantity,\n  pricingRulesFromProduct,\n  resolvePriceMatrix,\n  resolvePricingRules,\n} from './priceMatrix';\n\ntest('pricingRulesFromProduct maps unit-price discount groups', () => {\n  const rules = pricingRulesFromProduct({\n    currency: 'USD',\n    unitPrice: 12,\n    minimumPrice: 0,\n    setupPrice: 5,\n    setupPerGroup: true,\n    taxType: { taxPercent: 10 },\n    unitPriceDiscountGroup: {\n      groupRestricted: true,\n      discounts: [\n        { lowerLimit: 50, amount: 10 },\n        { lowerLimit: 'nope', amount: 5 },\n      ],\n    },\n  });\n  expect(rules).toMatchObject({\n    currency: 'USD',\n    taxPercent: 10,\n    product: {\n      unitPrice: 12,\n      minimumPrice: 0,\n      setupPrice: 5,\n      setupPerGroup: true,\n      discountGroup: {\n        groupRestricted: true,\n        discounts: [{ lowerLimit: 50, amount: 10 }],\n      },\n    },\n  });\n});\n\ntest('pricingRulesFromProduct falls back to discountGroup and defaults', () => {\n  expect(pricingRulesFromProduct({})).toBeNull();\n  expect(\n    pricingRulesFromProduct({\n      discountGroup: { discounts: [{ lowerLimit: 10, amount: 5 }] },\n    })\n  ).toMatchObject({\n    currency: 'AUD',\n    taxPercent: 0,\n    product: { unitPrice: 0, minimumPrice: null, setupPrice: 0 },\n  });\n});\n\ntest('resolvePricingRules prefers a live bundle', () => {\n  const live = { currency: 'NZD', product: { unitPrice: 1 } };\n  expect(resolvePricingRules(live, {})).toBe(live);\n  expect(resolvePricingRules({ unsupported: 'group_buy' }, {})).toBeNull();\n  expect(\n    resolvePricingRules(null, {\n      unitPriceDiscountGroup: { discounts: [{ lowerLimit: 5, amount: 1 }] },\n    })?.currency\n  ).toBe('AUD');\n});\n\ntest('currentOrderQuantity sums groups or reads job.quantity', () => {\n  expect(\n    currentOrderQuantity(\n      { variationsGroups: [{ quantity: 4 }, { quantity: '6' }, { quantity: 'x' }] },\n      { groupVariationFields: [{ id: 1 }] }\n    )\n  ).toBe(10);\n  expect(currentOrderQuantity({ quantity: 7 }, {})).toBe(7);\n  expect(currentOrderQuantity({}, {})).toBe(0);\n});\n\ntest('activeBandIndex highlights the highest matching break', () => {\n  const matrix = {\n    currency: 'AUD',\n    taxPercent: 0,\n    bands: [\n      { quantity: 1, upperLimit: 49, label: '1–49' },\n      { quantity: 50, upperLimit: null, label: '50+' },\n    ],\n    cells: [],\n  };\n  expect(activeBandIndex(matrix, 0)).toBe(-1);\n  expect(activeBandIndex(matrix, 1)).toBe(0);\n  expect(activeBandIndex(matrix, 49)).toBe(0);\n  expect(activeBandIndex(matrix, 50)).toBe(1);\n  expect(activeBandIndex({ ...matrix, bands: [] }, 10)).toBe(-1);\n});\n\ntest('resolvePriceMatrix returns a provided matrix', () => {\n  const matrix = {\n    currency: 'AUD',\n    taxPercent: 10,\n    bands: [{ quantity: 1, upperLimit: null, label: '1+' }],\n    cells: [],\n  };\n  expect(resolvePriceMatrix({ matrix })).toBe(matrix);\n});\n\ntest('resolvePriceMatrix builds from a product discount group', () => {\n  const matrix = resolvePriceMatrix({\n    product: {\n      currency: 'AUD',\n      unitPrice: 10,\n      unitPriceDiscountGroup: {\n        discounts: [{ lowerLimit: 100, amount: 10 }],\n      },\n    },\n    buildPriceMatrix: (rules) => ({\n      currency: rules.currency,\n      taxPercent: rules.taxPercent,\n      bands: [\n        { quantity: 1, upperLimit: 99, label: '1–99' },\n        { quantity: 100, upperLimit: null, label: '100+' },\n      ],\n      cells: [\n        { quantity: 1, costPerUnit: 10, unitPrice: 10, cost: 10, taxAmount: 0, totalCost: 10 },\n        { quantity: 100, costPerUnit: 9, unitPrice: 9, cost: 900, taxAmount: 0, totalCost: 900 },\n      ],\n    }),\n  });\n  expect(matrix?.bands.map((band) => band.quantity)).toEqual([1, 100]);\n  expect(matrix?.cells[1].costPerUnit).toBe(9);\n});\n\ntest('resolvePriceMatrix returns null without breaks or a matrix', () => {\n  expect(resolvePriceMatrix({ product: { unitPrice: 10 } })).toBeNull();\n  expect(resolvePriceMatrix({})).toBeNull();\n});\n"],"mappings":"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","ignoreList":[]}

package/lib/utils/products.d.ts

@@ -0,0 +1,40 @@
+export declare const supplierProductCreationTypes: Array<number>;
+export declare const embedProducts: any;
+export declare const embedProduct: {
+    component: {};
+    defaultJob: {};
+    domain: {
+        activeTheme: {
+            mainCss: {};
+        };
+        logo: {};
+    };
+    draftTemplates: {
+        file: {};
+        selectedByVariationFieldOptions: {};
+        editedByVariationFields: {};
+    };
+    groupBuyStatus: {};
+    groupVariationFields: {
+        options: {
+            linkedFile: {};
+            selectedBy: {};
+        };
+        selectedBy: {};
+    };
+    images: {};
+    independentVariationFields: {
+        options: {
+            linkedFile: {};
+            selectedBy: {};
+        };
+        selectedBy: {};
+    };
+    publicFiles: {};
+};
+export declare function productProfileUrl(product: any): any;
+export declare function productFeatureImageUrl(product: any, noImageSrc?: string): any;
+export declare function productHasGroups(product: any): boolean;
+export declare function productHasGroupRows(job: any): boolean;
+/** Product-level qty when there are no real group fields, or group rows never materialised. */
+export declare function needsProductLevelQuantity(product: any, job?: any): boolean;

package/lib/utils/products.js

@@ -0,0 +1,68 @@
+import { ProductType } from "./types";
+import { sanitizeProductVariationFields } from './variationFields';
+var productNotFound = require('../images/product-not-found.png');
+export var supplierProductCreationTypes = [ProductType.SUPPLIER_MOD, ProductType.SUPPLIER];
+export var embedProducts = {
+  domain: {
+    company: {},
+    logo: {}
+  },
+  featureImage: {},
+  images: {}
+};
+export var embedProduct = {
+  component: {},
+  defaultJob: {},
+  domain: {
+    activeTheme: {
+      mainCss: {}
+    },
+    logo: {}
+  },
+  draftTemplates: {
+    file: {},
+    selectedByVariationFieldOptions: {},
+    editedByVariationFields: {}
+  },
+  groupBuyStatus: {},
+  groupVariationFields: {
+    options: {
+      linkedFile: {},
+      selectedBy: {}
+    },
+    selectedBy: {}
+  },
+  images: {},
+  independentVariationFields: {
+    options: {
+      linkedFile: {},
+      selectedBy: {}
+    },
+    selectedBy: {}
+  },
+  publicFiles: {}
+};
+export function productProfileUrl(product) {
+  if (product && product.featureImage && product.featureImage.viewUrl) {
+    return String(product.featureImage.viewUrl);
+  }
+  var image = productNotFound["default"] || productNotFound;
+  return image ? image.src || image : '';
+}
+export function productFeatureImageUrl(product, noImageSrc) {
+  return product.featureImage && product.featureImage.viewUrl ? product.featureImage.viewUrl : product.images && product.images[0] && product.images[0].viewUrl ? product.images[0].viewUrl : noImageSrc ? noImageSrc : productProfileUrl(product);
+}
+export function productHasGroups(product) {
+  var _sanitizeProductVaria;
+  var fields = (_sanitizeProductVaria = sanitizeProductVariationFields(product)) === null || _sanitizeProductVaria === void 0 ? void 0 : _sanitizeProductVaria.groupVariationFields;
+  return Array.isArray(fields) && fields.length > 0;
+}
+export function productHasGroupRows(job) {
+  return Array.isArray(job === null || job === void 0 ? void 0 : job.variationsGroups) && job.variationsGroups.length > 0;
+}
+
+/** Product-level qty when there are no real group fields, or group rows never materialised. */
+export function needsProductLevelQuantity(product, job) {
+  return !productHasGroups(product) || !productHasGroupRows(job);
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/lib/utils/quantity.d.ts

@@ -0,0 +1,7 @@
+/** Product MOQ as a number, or 0 when unset / invalid. */
+export declare function productMinimumQuantity(product: any): number;
+/** Floor used for quantity inputs: at least 1, or the product MOQ when higher. */
+export declare function productMoqFloor(product: any): number;
+export declare function enforceMoqPerGroup(product: any): boolean;
+/** Quantity to seed on a newly added variation group. */
+export declare function defaultGroupQuantity(product: any): number;

package/lib/utils/quantity.js

@@ -0,0 +1,19 @@
+/** Product MOQ as a number, or 0 when unset / invalid. */
+export function productMinimumQuantity(product) {
+  var n = Number(product === null || product === void 0 ? void 0 : product.minimum);
+  return Number.isFinite(n) && n > 0 ? n : 0;
+}
+
+/** Floor used for quantity inputs: at least 1, or the product MOQ when higher. */
+export function productMoqFloor(product) {
+  return Math.max(1, productMinimumQuantity(product));
+}
+export function enforceMoqPerGroup(product) {
+  return Boolean(product === null || product === void 0 ? void 0 : product.minimumPerGroup);
+}
+
+/** Quantity to seed on a newly added variation group. */
+export function defaultGroupQuantity(product) {
+  return productMoqFloor(product);
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJuYW1lcyI6WyJwcm9kdWN0TWluaW11bVF1YW50aXR5IiwicHJvZHVjdCIsIm4iLCJOdW1iZXIiLCJtaW5pbXVtIiwiaXNGaW5pdGUiLCJwcm9kdWN0TW9xRmxvb3IiLCJNYXRoIiwibWF4IiwiZW5mb3JjZU1vcVBlckdyb3VwIiwiQm9vbGVhbiIsIm1pbmltdW1QZXJHcm91cCIsImRlZmF1bHRHcm91cFF1YW50aXR5Il0sInNvdXJjZXMiOlsiLi4vLi4vc3JjL3V0aWxzL3F1YW50aXR5LnRzIl0sInNvdXJjZXNDb250ZW50IjpbIi8qKiBQcm9kdWN0IE1PUSBhcyBhIG51bWJlciwgb3IgMCB3aGVuIHVuc2V0IC8gaW52YWxpZC4gKi9cbmV4cG9ydCBmdW5jdGlvbiBwcm9kdWN0TWluaW11bVF1YW50aXR5KHByb2R1Y3Q6IGFueSk6IG51bWJlciB7XG4gIGNvbnN0IG4gPSBOdW1iZXIocHJvZHVjdD8ubWluaW11bSk7XG4gIHJldHVybiBOdW1iZXIuaXNGaW5pdGUobikgJiYgbiA+IDAgPyBuIDogMDtcbn1cblxuLyoqIEZsb29yIHVzZWQgZm9yIHF1YW50aXR5IGlucHV0czogYXQgbGVhc3QgMSwgb3IgdGhlIHByb2R1Y3QgTU9RIHdoZW4gaGlnaGVyLiAqL1xuZXhwb3J0IGZ1bmN0aW9uIHByb2R1Y3RNb3FGbG9vcihwcm9kdWN0OiBhbnkpOiBudW1iZXIge1xuICByZXR1cm4gTWF0aC5tYXgoMSwgcHJvZHVjdE1pbmltdW1RdWFudGl0eShwcm9kdWN0KSk7XG59XG5cbmV4cG9ydCBmdW5jdGlvbiBlbmZvcmNlTW9xUGVyR3JvdXAocHJvZHVjdDogYW55KTogYm9vbGVhbiB7XG4gIHJldHVybiBCb29sZWFuKHByb2R1Y3Q/Lm1pbmltdW1QZXJHcm91cCk7XG59XG5cbi8qKiBRdWFudGl0eSB0byBzZWVkIG9uIGEgbmV3bHkgYWRkZWQgdmFyaWF0aW9uIGdyb3VwLiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGRlZmF1bHRHcm91cFF1YW50aXR5KHByb2R1Y3Q6IGFueSk6IG51bWJlciB7XG4gIHJldHVybiBwcm9kdWN0TW9xRmxvb3IocHJvZHVjdCk7XG59XG4iXSwibWFwcGluZ3MiOiJBQUFBO0FBQ0EsT0FBTyxTQUFTQSxzQkFBc0JBLENBQUNDLE9BQVksRUFBVTtFQUMzRCxJQUFNQyxDQUFDLEdBQUdDLE1BQU0sQ0FBQ0YsT0FBTyxhQUFQQSxPQUFPLHVCQUFQQSxPQUFPLENBQUVHLE9BQU8sQ0FBQztFQUNsQyxPQUFPRCxNQUFNLENBQUNFLFFBQVEsQ0FBQ0gsQ0FBQyxDQUFDLElBQUlBLENBQUMsR0FBRyxDQUFDLEdBQUdBLENBQUMsR0FBRyxDQUFDO0FBQzVDOztBQUVBO0FBQ0EsT0FBTyxTQUFTSSxlQUFlQSxDQUFDTCxPQUFZLEVBQVU7RUFDcEQsT0FBT00sSUFBSSxDQUFDQyxHQUFHLENBQUMsQ0FBQyxFQUFFUixzQkFBc0IsQ0FBQ0MsT0FBTyxDQUFDLENBQUM7QUFDckQ7QUFFQSxPQUFPLFNBQVNRLGtCQUFrQkEsQ0FBQ1IsT0FBWSxFQUFXO0VBQ3hELE9BQU9TLE9BQU8sQ0FBQ1QsT0FBTyxhQUFQQSxPQUFPLHVCQUFQQSxPQUFPLENBQUVVLGVBQWUsQ0FBQztBQUMxQzs7QUFFQTtBQUNBLE9BQU8sU0FBU0Msb0JBQW9CQSxDQUFDWCxPQUFZLEVBQVU7RUFDekQsT0FBT0ssZUFBZSxDQUFDTCxPQUFPLENBQUM7QUFDakMiLCJpZ25vcmVMaXN0IjpbXX0=

package/lib/utils/quantity.test.js

@@ -0,0 +1,42 @@
+import { defaultGroupQuantity, enforceMoqPerGroup, productMinimumQuantity, productMoqFloor } from './quantity';
+describe('product MOQ helpers', function () {
+  test('productMinimumQuantity reads numeric minimum', function () {
+    expect(productMinimumQuantity({
+      minimum: 50
+    })).toBe(50);
+    expect(productMinimumQuantity({
+      minimum: '25'
+    })).toBe(25);
+    expect(productMinimumQuantity({
+      minimum: 0
+    })).toBe(0);
+    expect(productMinimumQuantity({})).toBe(0);
+  });
+  test('productMoqFloor is at least 1', function () {
+    expect(productMoqFloor({
+      minimum: 50
+    })).toBe(50);
+    expect(productMoqFloor({
+      minimum: 0
+    })).toBe(1);
+    expect(productMoqFloor({})).toBe(1);
+  });
+  test('enforceMoqPerGroup follows minimumPerGroup', function () {
+    expect(enforceMoqPerGroup({
+      minimumPerGroup: true
+    })).toBe(true);
+    expect(enforceMoqPerGroup({
+      minimumPerGroup: false
+    })).toBe(false);
+    expect(enforceMoqPerGroup({})).toBe(false);
+  });
+  test('defaultGroupQuantity seeds at MOQ floor', function () {
+    expect(defaultGroupQuantity({
+      minimum: 100
+    })).toBe(100);
+    expect(defaultGroupQuantity({
+      minimum: 0
+    })).toBe(1);
+  });
+});
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,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

package/lib/utils/reconcileVariations.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Reconcile form variation arrays with a desired list (server quote or
+ * client-side visible fields). Membership is matched by variationField.id so
+ * conditional fields the server/client adds or removes are adopted without a
+ * full form reset that would throw away in-progress quantity edits.
+ */
+export declare function variationFieldId(variation: any): number | null;
+/** Sync isVisible / available onto current options by optionId (not index). */
+export declare function syncOptionVisibilityById(currentOptions: any[] | undefined, sourceOptions: any[] | undefined): boolean;
+/**
+ * Build the next variations array from `desiredVariations`, preserving user
+ * `value` / `variationFiles` for fields that already exist on the form.
+ */
+export declare function reconcileVariations(currentVariations: any[] | undefined, desiredVariations: any[] | undefined): {
+    variations: any[];
+    membershipChanged: boolean;
+    visibilityChanged: boolean;
+};
+/**
+ * Filter/order product fields by a visible-id set and reuse current values
+ * when present; otherwise use `buildEmptyVariation(field)`.
+ */
+export declare function buildDesiredVariationsFromFields(currentVariations: any[] | undefined, productFields: any[] | undefined, visibleFieldIds: Set<number>, buildEmptyVariation: (field: any) => any): any[];
+export declare function productFieldTemplatesById(product: any): Map<number, any>;
+export declare function productFieldsForPricingFields(pricingFields: any[] | undefined, product: any): any[] | null;