@artisan-commerce/products 0.9.0-canary.9 → 0.9.0-canary.91

package/dist/bundle.cjs

@@ -0,0 +1,1127 @@
+'use strict';
+
+const isBaseProduct = (product) => {
+  const { name, images, prices, productId } = product;
+  if (typeof name !== "string") {
+    return false;
+  }
+  if (typeof productId !== "string") {
+    return false;
+  }
+  if (typeof prices !== "object" || typeof prices === "object" && Object.keys(prices).length < 1) {
+    return false;
+  }
+  if (!Array.isArray(images)) {
+    return false;
+  }
+  if (product.questionId)
+    return false;
+  return true;
+};
+const isProductDetails = (product) => {
+  const validBaseProduct = isBaseProduct(product);
+  if (!validBaseProduct) {
+    return false;
+  }
+  const { questions } = product;
+  if (!Array.isArray(questions)) {
+    return false;
+  }
+  return true;
+};
+const isCartProduct = (product) => {
+  const validProductDetails = isProductDetails(product);
+  if (!validProductDetails) {
+    return false;
+  }
+  const { hash, createdAt, updatedAt } = product;
+  const { amount, priceCategory, comment, questionsAndAnswers } = product;
+  if (typeof hash !== "string") {
+    return false;
+  }
+  if (typeof createdAt !== "string") {
+    return false;
+  }
+  if (typeof updatedAt !== "string") {
+    return false;
+  }
+  if (typeof amount !== "number") {
+    return false;
+  }
+  if (typeof comment !== "string") {
+    return false;
+  }
+  if (!["NORMAL", "POINTS"].includes(priceCategory)) {
+    return false;
+  }
+  if (!Array.isArray(questionsAndAnswers)) {
+    return false;
+  }
+  return true;
+};
+const isFormCartProduct = (product) => {
+  var _a;
+  const validCartProduct = isCartProduct(product);
+  if (!validCartProduct) {
+    return false;
+  }
+  const { questions } = product;
+  if (!Array.isArray(questions)) {
+    return false;
+  }
+  const answers = (_a = questions == null ? void 0 : questions[0]) == null ? void 0 : _a.answers;
+  if ((answers == null ? void 0 : answers.length) && typeof answers[0].amount === "undefined") {
+    return false;
+  }
+  return true;
+};
+
+var assertions_utils = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  isBaseProduct: isBaseProduct,
+  isCartProduct: isCartProduct,
+  isFormCartProduct: isFormCartProduct,
+  isProductDetails: isProductDetails
+});
+
+const logError = (message) => {
+  if (process.env.NODE_ENV === "production") {
+    console.error(message);
+  } else {
+    throw new Error(message);
+  }
+};
+
+const getGroupType = (group) => {
+  const { min, max, type } = group;
+  if (type) {
+    if (type === "QUANTITY" || type === "SELECT") {
+      return "COUNTER";
+    }
+    return type;
+  }
+  if (min === 0 && max === 1) {
+    return "CHECKBOX";
+  }
+  if (min === 1 && max === 1) {
+    return "RADIO";
+  }
+  if (min === 0 && (max === 0 || max === Infinity)) {
+    return "COUNTER";
+  }
+  if (max >= min) {
+    return "COUNTER";
+  }
+  throw new Error(`Modifier group bad configured. min ${min}, max ${max}, type ${type}`);
+};
+const getModifierType = (config) => {
+  const { groupType, min, max, type } = config;
+  if (groupType === "RADIO") {
+    return "RADIO";
+  }
+  if (type) {
+    if (type === "QUANTITY" || type === "SELECT") {
+      return "COUNTER";
+    }
+    return type;
+  }
+  if (min === 1 && max === 1) {
+    return "RADIO";
+  }
+  if (min === 0 && max === 1) {
+    return "CHECKBOX";
+  }
+  if (min === 0 && (max === 0 || max === Infinity)) {
+    return "COUNTER";
+  }
+  if (max >= min) {
+    return "COUNTER";
+  }
+  return groupType;
+};
+const getModifierMin = (groupConfig) => {
+  const { min, modifiersCount } = groupConfig;
+  if (modifiersCount === 1) {
+    return min;
+  }
+  return 0;
+};
+const getModifierMax = (groupConfig) => {
+  const { max, type } = groupConfig;
+  const normalizedMax = max || Infinity;
+  if (type === "RADIO") {
+    return 1;
+  }
+  if (type === "CHECKBOX") {
+    return 1;
+  }
+  if (type === "COUNTER") {
+    return normalizedMax;
+  }
+  return normalizedMax;
+};
+const getModifierErrors = (modifier, amount, strict) => {
+  const errors = [];
+  const { max, min } = modifier;
+  if (amount > max) {
+    errors.push({
+      code: 101,
+      message: `Amount is heigher than the maximum allowed amount ${max}`
+    });
+  }
+  if (strict && amount < min) {
+    errors.push({
+      code: 102,
+      message: `Amount is lower than the minimum allowed amount ${min}`
+    });
+  }
+  return errors;
+};
+const getGroupModifierErrors = (group, strict) => {
+  const errors = [];
+  const { modifiers, data } = group;
+  const { min } = data;
+  let { max } = data;
+  if (min === 0 && max === 0) {
+    max = Infinity;
+  }
+  const amount = modifiers.reduce((acc, modifier) => {
+    return acc + modifier.amount;
+  }, 0);
+  if (amount > max) {
+    errors.push({
+      code: 201,
+      message: `Amount is heigher than the maximum allowed amount ${max}`
+    });
+  }
+  if (strict && amount < min) {
+    errors.push({
+      code: 202,
+      message: `Amount is lower than the minimum allowed amount ${min}`
+    });
+  }
+  return errors;
+};
+const getGroupRendererStatus = (group) => {
+  const { touched, errors, required, data, modifiers } = group;
+  const { min } = data;
+  const childrenWithError = modifiers.some((modifier) => modifier.status === "FAIL");
+  const childrenIdle = modifiers.some((modifier) => modifier.status === "IDLE");
+  const childrenIncomplete = modifiers.some((modifier) => modifier.status === "INCOMPLETE");
+  const amount = modifiers.reduce((acc, modifier) => {
+    return acc + modifier.amount;
+  }, 0);
+  return mapRenderStatusHelper({
+    touched,
+    errors,
+    required,
+    min,
+    amount,
+    childrenWithError,
+    childrenIdle,
+    childrenIncomplete,
+    reviewChildren: true
+  });
+};
+const getModifierRendererStatus = (modifier) => {
+  const childrenWithError = modifier.groups.some((group) => group.status === "FAIL");
+  const childrenIdle = modifier.groups.some((group) => group.status === "IDLE");
+  const childrenIncomplete = modifier.groups.some((group) => group.status === "INCOMPLETE");
+  const { touched, errors, required, min, amount } = modifier;
+  const reviewChildren = amount > 0;
+  return mapRenderStatusHelper({
+    touched,
+    errors,
+    required,
+    min,
+    amount,
+    childrenWithError,
+    childrenIdle,
+    childrenIncomplete,
+    reviewChildren
+  });
+};
+const mapRenderStatusHelper = (config) => {
+  const { touched, errors, required, min, amount, reviewChildren } = config;
+  const { childrenWithError, childrenIdle, childrenIncomplete } = config;
+  const firstRender = amount > 0 && !touched;
+  if (!firstRender && !touched && required) {
+    return "IDLE";
+  }
+  if (!firstRender && !touched && !required) {
+    return "OK";
+  }
+  if (errors.length) {
+    return "FAIL";
+  }
+  if (reviewChildren && childrenWithError) {
+    return "FAIL";
+  }
+  if (reviewChildren && (childrenIdle || childrenIncomplete)) {
+    return "INCOMPLETE";
+  }
+  if (amount < min) {
+    return "INCOMPLETE";
+  }
+  if (amount >= min) {
+    return "OK";
+  }
+  logError(`Unhandled case. Unable to compute the renderer status ${JSON.stringify({
+    touched,
+    errors,
+    required,
+    min,
+    amount
+  }, void 0, 2)}`);
+  return "FAIL";
+};
+const mapGlobalRendererStatus = (renderer) => {
+  const allChildrenOk = renderer.every((group) => {
+    const { status, required } = group;
+    const ok = status === "OK";
+    const idleNotRequired = status === "IDLE" && !required;
+    return ok || idleNotRequired;
+  });
+  if (allChildrenOk) {
+    return "OK";
+  }
+  const childrenIsIdle = renderer.every((group) => !group.touched);
+  if (childrenIsIdle) {
+    return "IDLE";
+  }
+  const chidrenWithError = renderer.some((group) => group.status === "FAIL");
+  if (chidrenWithError) {
+    return "FAIL";
+  }
+  return "INCOMPLETE";
+};
+
+var __defProp$7 = Object.defineProperty;
+var __defProps$5 = Object.defineProperties;
+var __getOwnPropDescs$5 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$7 = Object.getOwnPropertySymbols;
+var __hasOwnProp$7 = Object.prototype.hasOwnProperty;
+var __propIsEnum$7 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$7 = (obj, key, value) => key in obj ? __defProp$7(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$7 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$7.call(b, prop))
+      __defNormalProp$7(a, prop, b[prop]);
+  if (__getOwnPropSymbols$7)
+    for (var prop of __getOwnPropSymbols$7(b)) {
+      if (__propIsEnum$7.call(b, prop))
+        __defNormalProp$7(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$5 = (a, b) => __defProps$5(a, __getOwnPropDescs$5(b));
+const multiplyProductQA = (product) => {
+  return operationOnProductQA(product, (answer, productAmount) => {
+    const accAmount = answer.amount * productAmount;
+    const fixedAnswer = multiplyProductQA(__spreadProps$5(__spreadValues$7({}, answer), {
+      amount: accAmount
+    }));
+    return __spreadProps$5(__spreadValues$7({}, fixedAnswer), { amount: answer.amount * productAmount });
+  });
+};
+const divideProductQA = (product) => {
+  return operationOnProductQA(product, (answer, productAmount) => {
+    const fixedAnswer = divideProductQA(answer);
+    return __spreadProps$5(__spreadValues$7({}, fixedAnswer), { amount: answer.amount / productAmount });
+  });
+};
+const operationOnProductQA = (product, answerEnhancer) => {
+  const { amount: productAmount = 1, questionsAndAnswers = [] } = product;
+  const newQuestionsAndAnswers = questionsAndAnswers.map((question) => {
+    const answers = question.answers.map((answer) => {
+      return answerEnhancer(answer, productAmount);
+    });
+    return __spreadProps$5(__spreadValues$7({}, question), { answers });
+  });
+  return __spreadProps$5(__spreadValues$7({}, product), {
+    questionsAndAnswers: newQuestionsAndAnswers
+  });
+};
+
+var questionsAndAnswers_utils = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  divideProductQA: divideProductQA,
+  multiplyProductQA: multiplyProductQA,
+  operationOnProductQA: operationOnProductQA
+});
+
+var __defProp$6 = Object.defineProperty;
+var __defProps$4 = Object.defineProperties;
+var __getOwnPropDescs$4 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$6 = Object.getOwnPropertySymbols;
+var __hasOwnProp$6 = Object.prototype.hasOwnProperty;
+var __propIsEnum$6 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$6 = (obj, key, value) => key in obj ? __defProp$6(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$6 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$6.call(b, prop))
+      __defNormalProp$6(a, prop, b[prop]);
+  if (__getOwnPropSymbols$6)
+    for (var prop of __getOwnPropSymbols$6(b)) {
+      if (__propIsEnum$6.call(b, prop))
+        __defNormalProp$6(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$4 = (a, b) => __defProps$4(a, __getOwnPropDescs$4(b));
+const toCartProduct = (product, overrides = {}) => {
+  if (isCartProduct(product)) {
+    return __spreadValues$6(__spreadValues$6({}, product), overrides);
+  }
+  if (isProductDetails(product)) {
+    return toCartProductFromProductDetails(product, overrides);
+  }
+  const productDetails = toProductDetails(product);
+  return toCartProductFromProductDetails(productDetails, overrides);
+};
+const toCartProductFromProductDetails = (product, overrides = {}) => {
+  const { questionsAndAnswers, priceCategory, amount } = product;
+  const newCartProduct = __spreadValues$6(__spreadProps$4(__spreadValues$6({}, product), {
+    questionsAndAnswers: questionsAndAnswers != null ? questionsAndAnswers : [],
+    amount: amount != null ? amount : 0,
+    priceCategory: priceCategory != null ? priceCategory : "NORMAL",
+    comment: "",
+    alerts: [],
+    hash: "",
+    createdAt: "",
+    updatedAt: ""
+  }), overrides);
+  return newCartProduct;
+};
+const toProductDetails = (product, overrides = {}) => {
+  return __spreadValues$6(__spreadProps$4(__spreadValues$6({}, product), {
+    addDirectlyToCart: true,
+    isPriceVip: false,
+    manufacturer: [],
+    maxAmountForSale: 0,
+    questions: [],
+    schedule: [],
+    benefitId: null,
+    categories: null
+  }), overrides);
+};
+const toFormCartProduct = (product, overrides = {}) => {
+  if (isFormCartProduct(product)) {
+    return __spreadValues$6(__spreadValues$6({}, product), overrides);
+  }
+  if (isProductDetails(product)) {
+    return toFormCartProductFromProductDetails(product, overrides);
+  }
+  const productDetails = toProductDetails(product);
+  return toFormCartProductFromProductDetails(productDetails, overrides);
+};
+const toFormCartProductHelper = (product, overrides = {}) => {
+  const fixedProduct = divideProductQA(product);
+  const { priceCategory, productId, amount } = fixedProduct;
+  const newQuestions = fixedProduct.questions.map((question) => {
+    var _a;
+    const pairQuestion = (_a = fixedProduct.questionsAndAnswers) == null ? void 0 : _a.find((q) => {
+      return q.questionId === question.questionId;
+    });
+    const selectedQuestion = pairQuestion != null ? pairQuestion : question;
+    const { questionId, min, max } = selectedQuestion;
+    const answerConfig = {
+      min,
+      max,
+      type: getGroupType(selectedQuestion),
+      modifiersCount: question.answers.length};
+    return __spreadProps$4(__spreadValues$6({}, selectedQuestion), {
+      answers: question.answers.map((answer) => {
+        var _a2, _b, _c;
+        const pairAnswer = pairQuestion == null ? void 0 : pairQuestion.answers.find((a) => {
+          return a.amount > 0 && a.productId === answer.productId;
+        });
+        const selectedAnswer = pairAnswer != null ? pairAnswer : answer;
+        const min2 = getModifierMin(answerConfig);
+        const max2 = getModifierMax(answerConfig);
+        const type = getModifierType({
+          min: min2,
+          max: max2,
+          groupType: answerConfig.type,
+          type: selectedAnswer.renderType
+        });
+        const nested = (_b = (_a2 = selectedAnswer.questions) == null ? void 0 : _a2.length) != null ? _b : 0;
+        const partialNewAnswer = __spreadProps$4(__spreadValues$6({}, selectedAnswer), {
+          amount: (_c = selectedAnswer == null ? void 0 : selectedAnswer.amount) != null ? _c : 0,
+          priceCategory,
+          questionId,
+          min: min2,
+          max: max2,
+          renderType: type
+        });
+        return __spreadProps$4(__spreadValues$6({}, partialNewAnswer), {
+          questions: nested ? toFormCartProductHelper(partialNewAnswer).questions : []
+        });
+      })
+    });
+  });
+  return __spreadValues$6(__spreadProps$4(__spreadValues$6({}, fixedProduct), {
+    questions: newQuestions
+  }), overrides);
+};
+const toFormCartProductFromProductDetails = (product, overrides = {}) => {
+  const cartProduct = toCartProductFromProductDetails(product);
+  return toFormCartProductHelper(cartProduct, overrides);
+};
+const toFormCartProductFromAnswer = (modifier, overrides = {}) => {
+  return toFormCartProductHelper(modifier, overrides);
+};
+const normalizeProductDetails = (product) => {
+  const { questions } = product;
+  return __spreadProps$4(__spreadValues$6({}, product), {
+    questions: questions.map((question) => {
+      const { answers } = question;
+      return __spreadProps$4(__spreadValues$6({}, question), {
+        answers: answers.map((answer) => {
+          const { questions: questions2 } = answer;
+          return __spreadProps$4(__spreadValues$6({}, answer), {
+            questions: questions2 != null ? questions2 : []
+          });
+        })
+      });
+    })
+  });
+};
+
+var transformers_utils = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  normalizeProductDetails: normalizeProductDetails,
+  toCartProduct: toCartProduct,
+  toFormCartProduct: toFormCartProduct,
+  toFormCartProductFromAnswer: toFormCartProductFromAnswer,
+  toFormCartProductFromProductDetails: toFormCartProductFromProductDetails,
+  toFormCartProductHelper: toFormCartProductHelper
+});
+
+var __defProp$5 = Object.defineProperty;
+var __defProps$3 = Object.defineProperties;
+var __getOwnPropDescs$3 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$5 = Object.getOwnPropertySymbols;
+var __hasOwnProp$5 = Object.prototype.hasOwnProperty;
+var __propIsEnum$5 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$5 = (obj, key, value) => key in obj ? __defProp$5(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$5 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$5.call(b, prop))
+      __defNormalProp$5(a, prop, b[prop]);
+  if (__getOwnPropSymbols$5)
+    for (var prop of __getOwnPropSymbols$5(b)) {
+      if (__propIsEnum$5.call(b, prop))
+        __defNormalProp$5(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$3 = (a, b) => __defProps$3(a, __getOwnPropDescs$3(b));
+const buildProductFromRenderer = (renderer, product) => {
+  const baseCartProduct = toCartProduct(product);
+  return __spreadProps$3(__spreadValues$5({}, baseCartProduct), {
+    questionsAndAnswers: buildQuestionAndAnswersFromRenderer(renderer),
+    updatedAt: ""
+  });
+};
+const buildQuestionAndAnswersFromRenderer = (groups) => {
+  return groups.map((group) => {
+    return __spreadProps$3(__spreadValues$5({}, group.data), {
+      answers: buildAnswersFromRenderer(group.modifiers)
+    });
+  });
+};
+const buildAnswersFromRenderer = (modifiers) => {
+  return modifiers.map((modifier) => {
+    if (!modifier.amount) {
+      return __spreadProps$3(__spreadValues$5({}, modifier.data), { questionsAndAnswers: [] });
+    }
+    return __spreadProps$3(__spreadValues$5({}, modifier.data), {
+      questionsAndAnswers: buildQuestionAndAnswersFromRenderer(modifier.groups)
+    });
+  });
+};
+
+var __defProp$4 = Object.defineProperty;
+var __getOwnPropSymbols$4 = Object.getOwnPropertySymbols;
+var __hasOwnProp$4 = Object.prototype.hasOwnProperty;
+var __propIsEnum$4 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$4 = (obj, key, value) => key in obj ? __defProp$4(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$4 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$4.call(b, prop))
+      __defNormalProp$4(a, prop, b[prop]);
+  if (__getOwnPropSymbols$4)
+    for (var prop of __getOwnPropSymbols$4(b)) {
+      if (__propIsEnum$4.call(b, prop))
+        __defNormalProp$4(a, prop, b[prop]);
+    }
+  return a;
+};
+const getRendererPathNode = (groups, path) => {
+  let remainingPath = [...path];
+  let segments = groups;
+  let node = groups[0];
+  while (remainingPath.length) {
+    node = findNodeInPath(segments, remainingPath[0]);
+    remainingPath = remainingPath.slice(1);
+    const isGroup = Object.prototype.hasOwnProperty.call(node, "modifiers");
+    if (isGroup) {
+      segments = node.modifiers;
+    } else {
+      segments = node.groups;
+    }
+  }
+  return node;
+};
+const setRendererPathNode = (renderer, path, replacement) => {
+  let remainingPath = [...path];
+  let segments = renderer;
+  let node = findNodeInPath(segments, remainingPath[0]);
+  let isGroup = Object.prototype.hasOwnProperty.call(node, "modifiers");
+  while (remainingPath.length > 1) {
+    node = findNodeInPath(segments, remainingPath[0]);
+    remainingPath = remainingPath.slice(1);
+    isGroup = Object.prototype.hasOwnProperty.call(node, "modifiers");
+    if (isGroup) {
+      segments = [...node.modifiers];
+    } else {
+      segments = [...node.groups];
+    }
+  }
+  const replacerId = remainingPath[0];
+  if (path.length === 1) {
+    node = { groups: renderer };
+    isGroup = false;
+  }
+  if (isGroup) {
+    const newModifiers = node.modifiers.map((item) => {
+      if (item.id === replacerId) {
+        return __spreadValues$4({}, replacement);
+      }
+      return __spreadValues$4({}, item);
+    });
+    node.modifiers = newModifiers;
+  } else {
+    const newGroups = node.groups.map((item) => {
+      if (item.id === replacerId) {
+        return __spreadValues$4({}, replacement);
+      }
+      return __spreadValues$4({}, item);
+    });
+    node.groups = newGroups;
+  }
+  if (path.length === 1) {
+    return [...node.groups];
+  }
+  return [...renderer];
+};
+const findNodeInPath = (segments, segmentId) => {
+  const node = segments.find((segment) => {
+    return segment.id === segmentId;
+  });
+  if (!node) {
+    throw new Error(`Path segment ${segmentId} doesn't exist in segments ${JSON.stringify(segments.map((segment) => segment.id))}`);
+  }
+  return node;
+};
+
+const getProductTotals = (product, amount = product.amount > 0 ? product.amount : 1) => {
+  if (amount < 1) {
+    throw new Error("Cannot set the amount of getProductTotals with a value less than 1");
+  }
+  const cartProduct = product;
+  const { priceCategory } = cartProduct;
+  const isPoints = priceCategory === "POINTS";
+  const sanitize = !!cartProduct.updatedAt;
+  const sanitized = sanitize ? divideProductQA(cartProduct) : product;
+  return {
+    unitGrossPrice: getProductGrossPrice(sanitized, 1),
+    unitTotalDiscounts: getProductTotalDiscounts(),
+    unitTotalTaxes: !isPoints ? getProductTotalTaxes(sanitized, 1) : 0,
+    unitNetPrice: getProductNetPrice(sanitized, 1),
+    amount,
+    grossPrice: getProductGrossPrice(sanitized, amount),
+    totalDiscounts: getProductTotalDiscounts(),
+    totalTaxes: !isPoints ? getProductTotalTaxes(sanitized, amount) : 0,
+    netPrice: getProductNetPrice(sanitized, amount)
+  };
+};
+const getProductTotalTaxes = (product, setAmount) => {
+  const cartProduct = toCartProduct(product, { amount: setAmount });
+  const { prices, amount, priceCategory } = cartProduct;
+  const { taxes, grossPrice } = prices[priceCategory];
+  const taxTotal = getTaxTotal(taxes, grossPrice);
+  const questionsSum = getModifiersTotalTaxes(cartProduct, setAmount);
+  if (taxTotal === null || questionsSum === null) {
+    return null;
+  }
+  return questionsSum + taxTotal * amount;
+};
+const getModifiersTotalTaxes = (product, setAmount) => {
+  var _a, _b;
+  return (_b = (_a = product.questionsAndAnswers) == null ? void 0 : _a.reduce((acc, question) => {
+    const answersSum = question.answers.reduce((acc2, answer) => {
+      const { prices, amount, priceCategory } = answer;
+      const { taxes, grossPrice } = prices[priceCategory];
+      const taxTotal = getTaxTotal(taxes, grossPrice);
+      const childrenTotal = getModifiersTotalTaxes(answer, setAmount);
+      return acc2 + amount * (Number(taxTotal) + childrenTotal);
+    }, 0);
+    return acc + answersSum * setAmount;
+  }, 0)) != null ? _b : 0;
+};
+const getProductGrossPrice = (product, setAmount) => {
+  return getProductFieldPrice(product, "grossPrice", setAmount);
+};
+const getProductTotalDiscounts = (product, setAmount) => {
+  return null;
+};
+const getProductNetPrice = (product, setAmount) => {
+  return getProductFieldPrice(product, "netPrice", setAmount);
+};
+const getProductFieldPrice = (product, field, setAmount) => {
+  const cartProduct = toCartProduct(product, { amount: setAmount });
+  const { prices, amount, priceCategory } = cartProduct;
+  const priceField = prices[priceCategory][field];
+  const questionsSum = getModifiersFieldTotal(cartProduct, field);
+  return (questionsSum + priceField) * amount;
+};
+const getModifiersFieldTotal = (product, field) => {
+  var _a, _b;
+  return (_b = (_a = product.questionsAndAnswers) == null ? void 0 : _a.reduce((acc, question) => {
+    const answersSum = question.answers.reduce((acc2, answer) => {
+      const { prices, amount, priceCategory } = answer;
+      const priceField = prices[priceCategory][field];
+      const childrenTotal = getModifiersFieldTotal(answer, field);
+      return acc2 + amount * (priceField + childrenTotal);
+    }, 0);
+    return acc + answersSum;
+  }, 0)) != null ? _b : 0;
+};
+const getTaxTotal = (taxes, grossPrice) => {
+  if (!taxes.length) {
+    return null;
+  }
+  return taxes.reduce((acc, tax) => {
+    return acc + tax.percentage / 100 * grossPrice;
+  }, 0);
+};
+
+var __defProp$3 = Object.defineProperty;
+var __getOwnPropSymbols$3 = Object.getOwnPropertySymbols;
+var __hasOwnProp$3 = Object.prototype.hasOwnProperty;
+var __propIsEnum$3 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$3 = (obj, key, value) => key in obj ? __defProp$3(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$3 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$3.call(b, prop))
+      __defNormalProp$3(a, prop, b[prop]);
+  if (__getOwnPropSymbols$3)
+    for (var prop of __getOwnPropSymbols$3(b)) {
+      if (__propIsEnum$3.call(b, prop))
+        __defNormalProp$3(a, prop, b[prop]);
+    }
+  return a;
+};
+const _State = class {
+  constructor(state) {
+    this._state = state;
+    this._initialState = state;
+  }
+  static getInstance(initialState) {
+    if (!_State._instance) {
+      _State._instance = new _State(initialState);
+    }
+    return _State._instance;
+  }
+  setState(overrides) {
+    this._state = __spreadValues$3(__spreadValues$3({}, this._state), overrides);
+  }
+  get state() {
+    if (this._state === null) {
+      throw new Error("The state has not been initialized, make sure to call State.init beforehand");
+    }
+    return this._state;
+  }
+  checkInit() {
+    return !!this._state;
+  }
+  reset() {
+    this._state = this._initialState;
+  }
+};
+let State$1 = _State;
+State$1._instance = null;
+
+const initialState = {
+  forms: {}
+};
+const State = () => {
+  return State$1.getInstance(initialState);
+};
+
+var __defProp$2 = Object.defineProperty;
+var __defProps$2 = Object.defineProperties;
+var __getOwnPropDescs$2 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$2 = Object.getOwnPropertySymbols;
+var __hasOwnProp$2 = Object.prototype.hasOwnProperty;
+var __propIsEnum$2 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$2 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$2.call(b, prop))
+      __defNormalProp$2(a, prop, b[prop]);
+  if (__getOwnPropSymbols$2)
+    for (var prop of __getOwnPropSymbols$2(b)) {
+      if (__propIsEnum$2.call(b, prop))
+        __defNormalProp$2(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$2 = (a, b) => __defProps$2(a, __getOwnPropDescs$2(b));
+const buildRenderer = (product, config, previous) => {
+  const { rootId, path } = config;
+  const groupsRenderer = product.questions.map((modifierGroup) => {
+    const previousGroup = previous == null ? void 0 : previous.find((group) => {
+      return group.id === modifierGroup.questionId;
+    });
+    return buildModifierGroupRenderer(modifierGroup, {
+      amount: product.amount,
+      rootId,
+      path: [...path]
+    }, previousGroup);
+  });
+  return groupsRenderer;
+};
+const buildModifierGroupRenderer = (modifierGroup, parentConfig, previous) => {
+  const { questionId, name, description, max, min, images } = modifierGroup;
+  const { amount, rootId, path } = parentConfig;
+  const { errors, touched } = previous != null ? previous : {};
+  const partialGroup = {
+    id: questionId,
+    name,
+    description: description != null ? description : "",
+    images: [...images != null ? images : []],
+    data: __spreadValues$2({}, modifierGroup),
+    errors: errors != null ? errors : [],
+    touched: touched != null ? touched : false,
+    status: "IDLE",
+    hidden: amount < 1,
+    required: min > 0,
+    type: getGroupType(modifierGroup)
+  };
+  const config = {
+    rootId,
+    type: partialGroup.type,
+    modifiersCount: modifierGroup.answers.length,
+    amount,
+    path: [...path, questionId]
+  };
+  const modifiersRenderer = modifierGroup.answers.map((modifier) => {
+    const previousModifier = previous == null ? void 0 : previous.modifiers.find((modifierRenderer) => {
+      return modifierRenderer.id === modifier.productId;
+    });
+    return buildModifierRenderer(modifier, config, previousModifier);
+  });
+  const groupWithoutStatus = __spreadProps$2(__spreadValues$2({}, partialGroup), {
+    modifiers: modifiersRenderer
+  });
+  return __spreadProps$2(__spreadValues$2({}, groupWithoutStatus), {
+    status: getGroupRendererStatus(groupWithoutStatus)
+  });
+};
+const buildModifierRenderer = (modifier, config, previous) => {
+  var _a, _b;
+  const { productId, questionId, name, images, amount } = modifier;
+  const { renderType, min, max } = modifier;
+  const subproduct = toFormCartProductFromAnswer(modifier);
+  const { rootId, path } = config;
+  const updatedPath = [...path, productId];
+  const groups = buildRenderer(subproduct, {
+    rootId,
+    path: updatedPath
+  }, previous == null ? void 0 : previous.groups);
+  const modifierWithoutStatus = {
+    id: productId,
+    groupId: questionId,
+    name,
+    images: [...images],
+    amount,
+    data: __spreadValues$2({}, modifier),
+    groups,
+    errors: (_a = previous == null ? void 0 : previous.errors) != null ? _a : [],
+    hidden: config.amount < 1,
+    min,
+    max,
+    required: min > 0,
+    touched: (_b = previous == null ? void 0 : previous.touched) != null ? _b : false,
+    status: "IDLE",
+    totals: getProductTotals(__spreadProps$2(__spreadValues$2({}, modifier), { amount })),
+    type: renderType,
+    handleChange: (amount2) => {
+      handleModifierChange(config.rootId, updatedPath, amount2);
+    }
+  };
+  return __spreadProps$2(__spreadValues$2({}, modifierWithoutStatus), {
+    status: getModifierRendererStatus(modifierWithoutStatus)
+  });
+};
+const handleModifierChange = (productId, path, amount) => {
+  const forms = __spreadValues$2({}, State().state.forms);
+  const form = forms[productId];
+  const node = getRendererPathNode(form.renderer, path);
+  let newRenderer = updateModifier(form.renderer, path, node, amount, false);
+  newRenderer = updateParentGroup(productId, newRenderer, path, false);
+  const updatedProduct = buildProductFromRenderer(newRenderer, form.product);
+  const updatedForm = __spreadProps$2(__spreadValues$2({}, form), {
+    renderer: newRenderer,
+    product: updatedProduct,
+    status: mapGlobalRendererStatus(newRenderer)
+  });
+  const newForms = __spreadProps$2(__spreadValues$2({}, forms), { [productId]: updatedForm });
+  State().setState({ forms: newForms });
+  const returnForm = __spreadValues$2({}, updatedForm);
+  delete returnForm.callback;
+  form.callback(returnForm);
+};
+const updateModifier = (renderer, path, node, amount, strict) => {
+  const newModifierRenderer = __spreadProps$2(__spreadValues$2({}, node), {
+    amount,
+    touched: true,
+    errors: getModifierErrors(node, amount, strict),
+    totals: getProductTotals(__spreadProps$2(__spreadValues$2({}, node.data), { amount })),
+    data: __spreadProps$2(__spreadValues$2({}, node.data), {
+      amount
+    })
+  });
+  newModifierRenderer.status = getModifierRendererStatus(newModifierRenderer);
+  return setRendererPathNode(renderer, path, newModifierRenderer);
+};
+const updateParentGroup = (rootId, renderer, path, strict) => {
+  const parentPath = path.slice(0, -1);
+  const parentGroup = getRendererPathNode(renderer, parentPath);
+  let newModifierRenderers = [...parentGroup.modifiers];
+  if (parentGroup.type === "RADIO" && !strict) {
+    newModifierRenderers = parentGroup.modifiers.map((modifier) => {
+      if (modifier.type !== "RADIO") {
+        return __spreadValues$2({}, modifier);
+      }
+      if (modifier.id === path[path.length - 1]) {
+        return __spreadValues$2({}, modifier);
+      }
+      return __spreadProps$2(__spreadValues$2({}, modifier), {
+        amount: 0,
+        error: "",
+        totals: getProductTotals(__spreadProps$2(__spreadValues$2({}, modifier.data), { amount: 0 })),
+        data: __spreadProps$2(__spreadValues$2({}, modifier.data), {
+          amount: 0
+        })
+      });
+    });
+  }
+  newModifierRenderers = newModifierRenderers.map((modifier) => {
+    const subproduct = toFormCartProductFromAnswer(modifier.data);
+    const newPath = [...path.slice(0, -1), modifier.id];
+    const updatedModifier = __spreadProps$2(__spreadValues$2({}, modifier), {
+      groups: buildRenderer(subproduct, {
+        rootId,
+        path: newPath
+      }, modifier.groups)
+    });
+    updatedModifier.errors = getModifierErrors(updatedModifier, updatedModifier.amount, strict);
+    updatedModifier.status = getModifierRendererStatus(updatedModifier);
+    return updatedModifier;
+  });
+  const updatedGroupAnswers = newModifierRenderers.map((modifier) => {
+    return __spreadValues$2({}, modifier.data);
+  });
+  const newGroupData = __spreadProps$2(__spreadValues$2({}, parentGroup.data), { answers: updatedGroupAnswers });
+  const newGroupRenderer = __spreadProps$2(__spreadValues$2({}, parentGroup), {
+    touched: true,
+    modifiers: newModifierRenderers,
+    data: newGroupData
+  });
+  newGroupRenderer.errors = getGroupModifierErrors(newGroupRenderer, strict);
+  newGroupRenderer.status = getGroupRendererStatus(newGroupRenderer);
+  let newRenderer = setRendererPathNode(renderer, parentPath, newGroupRenderer);
+  if (parentPath.length > 1) {
+    newRenderer = updateParentModifier(rootId, newRenderer, parentPath, strict);
+  }
+  return newRenderer;
+};
+const updateParentModifier = (rootId, renderer, path, strict) => {
+  const parentPath = path.slice(0, -1);
+  const parentModifier = getRendererPathNode(renderer, parentPath);
+  const updatedModifierQuestions = parentModifier.groups.map((group) => {
+    return __spreadValues$2({}, group.data);
+  });
+  const newAnswers = buildQuestionAndAnswersFromRenderer(parentModifier.groups);
+  const newModifierData = __spreadProps$2(__spreadValues$2({}, parentModifier.data), {
+    questions: updatedModifierQuestions,
+    questionsAndAnswers: newAnswers
+  });
+  const newModifierGroups = parentModifier.groups.map((group) => {
+    const newGroup = __spreadValues$2({}, group);
+    newGroup.errors = getGroupModifierErrors(newGroup, strict);
+    newGroup.status = getGroupRendererStatus(newGroup);
+    return newGroup;
+  });
+  const newModifierRenderer = __spreadProps$2(__spreadValues$2({}, parentModifier), {
+    touched: true,
+    groups: newModifierGroups,
+    data: newModifierData
+  });
+  newModifierRenderer.errors = getModifierErrors(newModifierRenderer, newModifierRenderer.amount, strict);
+  newModifierRenderer.status = getModifierRendererStatus(newModifierRenderer);
+  let newRenderer = setRendererPathNode(renderer, parentPath, newModifierRenderer);
+  if (parentPath.length > 1) {
+    newRenderer = updateParentGroup(rootId, newRenderer, parentPath, strict);
+  }
+  return newRenderer;
+};
+
+var __defProp$1 = Object.defineProperty;
+var __defProps$1 = Object.defineProperties;
+var __getOwnPropDescs$1 = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols$1 = Object.getOwnPropertySymbols;
+var __hasOwnProp$1 = Object.prototype.hasOwnProperty;
+var __propIsEnum$1 = Object.prototype.propertyIsEnumerable;
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues$1 = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp$1.call(b, prop))
+      __defNormalProp$1(a, prop, b[prop]);
+  if (__getOwnPropSymbols$1)
+    for (var prop of __getOwnPropSymbols$1(b)) {
+      if (__propIsEnum$1.call(b, prop))
+        __defNormalProp$1(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps$1 = (a, b) => __defProps$1(a, __getOwnPropDescs$1(b));
+const validateProduct = (productId) => {
+  const forms = __spreadValues$1({}, State().state.forms);
+  const form = forms[productId];
+  const { renderer, callback, product } = form;
+  let latestRenderer = [...renderer];
+  renderer.forEach((group) => {
+    const path = [group.id];
+    latestRenderer = validateChildModifiers(group, latestRenderer, productId, path);
+  });
+  const updatedProduct = buildProductFromRenderer(latestRenderer, product);
+  const updatedForm = __spreadProps$1(__spreadValues$1({}, form), {
+    renderer: latestRenderer,
+    product: updatedProduct,
+    status: mapGlobalRendererStatus(latestRenderer)
+  });
+  const newForms = __spreadProps$1(__spreadValues$1({}, forms), { [productId]: updatedForm });
+  State().setState({ forms: newForms });
+  const returnForm = __spreadValues$1({}, updatedForm);
+  delete returnForm.callback;
+  callback(returnForm);
+  return updatedForm.status;
+};
+const validateChildModifiers = (group, renderer, productId, path) => {
+  const { modifiers, id } = group;
+  const isLeaft = !modifiers.length;
+  let latestRenderer = [...renderer];
+  if (!isLeaft) {
+    modifiers.forEach((modifier) => {
+      const newPath = [...path, modifier.id];
+      latestRenderer = validateChildGroups(modifier, latestRenderer, productId, newPath);
+    });
+    return latestRenderer;
+  } else {
+    console.warn(`Attempting to validate a Modifier group without modifiers, this will likely result in unexpected behaviour. 
+      Please update the bad group ${id} of product ${0}.`);
+    return latestRenderer;
+  }
+};
+const validateChildGroups = (modifier, renderer, productId, path) => {
+  const { groups, amount, status, required } = modifier;
+  const isLeaft = !groups.length || amount === 0;
+  let latestRenderer = [...renderer];
+  if (isLeaft) {
+    const badIdle = status === "IDLE" && required;
+    const badStatus = badIdle || status === "FAIL" || status === "INCOMPLETE";
+    const newStatus = badStatus ? "FAIL" : status;
+    const replacement = __spreadProps$1(__spreadValues$1({}, modifier), { status: newStatus });
+    const newPath = [...path];
+    latestRenderer = updateModifier(latestRenderer, newPath, replacement, replacement.amount, true);
+    latestRenderer = updateParentGroup(productId, latestRenderer, newPath, true);
+  } else {
+    groups.forEach((group) => {
+      const newPath = [...path, group.id];
+      latestRenderer = validateChildModifiers(group, latestRenderer, productId, newPath);
+    });
+  }
+  return latestRenderer;
+};
+
+const createForm = (product) => {
+  var _a;
+  const formCartProduct = toFormCartProduct(product, {
+    amount: (_a = product.amount) != null ? _a : 1
+  });
+  const renderer = buildRenderer(formCartProduct, {
+    rootId: formCartProduct.productId,
+    path: []
+  });
+  const updatedProduct = buildProductFromRenderer(renderer, product);
+  return {
+    product: updatedProduct,
+    renderer,
+    validate: () => validateProduct(product.productId),
+    status: mapGlobalRendererStatus(renderer)
+  };
+};
+
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+const registerModifiersForm = (product, callback) => {
+  const { productId } = product;
+  const { forms } = State().state;
+  const formExists = !!forms[productId];
+  if (formExists) {
+    logError(`Form for product with id ${productId} has already been register. Please unsubscribe if you need to register a new form.`);
+    return () => {
+    };
+  }
+  const form = createForm(product);
+  const newForms = __spreadProps(__spreadValues({}, forms), { [productId]: __spreadProps(__spreadValues({}, form), { callback }) });
+  State().setState({ forms: newForms });
+  callback(__spreadValues({}, form));
+  return () => unsubscriber(productId);
+};
+const unsubscriber = (productId) => {
+  const { forms } = State().state;
+  const newForms = __spreadValues({}, forms);
+  delete newForms[productId];
+  State().setState({ forms: newForms });
+};
+
+exports.assertions = assertions_utils;
+exports.getProductTotals = getProductTotals;
+exports.modifierUtils = questionsAndAnswers_utils;
+exports.registerModifiersForm = registerModifiersForm;
+exports.transformers = transformers_utils;
+exports.validateProduct = validateProduct;
+//# sourceMappingURL=bundle.cjs.map