addio-admin-sdk 1.7.102 → 1.7.104

package/dist/rules/GR/utils/products.js

@@ -27,19 +27,24 @@ const floor_1 = __importDefault(require("lodash/floor"));
 const Cart_1 = require("../../../Interfaces/Cart");
 const G2_1 = require("../../../Interfaces/G2");
 const IDiscountRule_1 = require("../../../Interfaces/Rules/IDiscountRule");
+// General utils
 const string_1 = require("../../../utils/string");
 const locale_1 = require("../../../utils/locale");
 const inventories_1 = require("../../../utils/inventories");
 const products_1 = require("../../../utils/products");
+// Specitic utils
 const expedition_1 = require("./expedition");
 const products_2 = require("../constants/products");
 const g2_1 = require("./g2");
 const cart_1 = require("./cart");
+// Specific interfaces
 const products_3 = require("../interfaces/products");
 const data_1 = require("../interfaces/data");
 const cart_2 = require("../interfaces/cart");
 const upsells_1 = require("./upsells");
 const object_1 = require("../../../utils/object");
+// ----------------------------------------------------------------------------------------------------------
+// #region PRODUCT UNITS
 const pluralSellUnits = {
     p2: { fr: 'pi²', en: 'sqft' },
     sac: { fr: 'sacs', en: 'bags' },
@@ -85,6 +90,14 @@ const sellUnitsBySlug = {
     pqt: { fr: 'paquet', en: 'bundle' },
     '': { fr: 'unité', en: 'unit' }
 };
+/**
+ * @description Returns sell unit label in correct language for a specific product's other_units
+ * @param {IFilledDimensionUnits[] | undefined} otherUnits The unit array we have to check to get the sell unit
+ * @param {string | undefined} locale The language in which we want to return the label
+ * @param {string[]} returnUnitForSlugs An array of the slugs we want to return the unit label for
+ * @param {boolean} options.returnPlural If plural version should be returned
+ * @param {boolean} options.returnShortByDefault If short version should be prioritized
+ */
 const getProductSellUnitLabel = (otherUnits, locale = 'fr', returnUnitForSlugs, options = {}) => {
     if (!!!otherUnits)
         return '';
@@ -94,6 +107,15 @@ const getProductSellUnitLabel = (otherUnits, locale = 'fr', returnUnitForSlugs,
     return (0, exports.getUnitLabelWithSlug)(sellingUnit.unit_slug, locale, options.returnPlural, returnUnitForSlugs, options.returnShortByDefault);
 };
 exports.getProductSellUnitLabel = getProductSellUnitLabel;
+/**
+ * @description Returns unit label in correct language for a specific product's other_units
+ * @param {IFilledDimensionUnits[] | undefined} otherUnits The unit array we have to check to get the sell unit
+ * @param {string} type The unit type to check
+ * @param {string | undefined} locale The language in which we want to return the label
+ * @param {string[]} returnUnitForSlugs An array of the slugs we want to return the unit label for
+ * @param {boolean} options.returnPlural If plural version should be returned
+ * @param {boolean} options.returnShortByDefault If short version should be prioritized
+ */
 const getProductUnitLabel = (otherUnits, type, locale = 'fr', returnUnitForSlugs, options = {}) => {
     if (!!!otherUnits)
         return '';
@@ -103,6 +125,14 @@ const getProductUnitLabel = (otherUnits, type, locale = 'fr', returnUnitForSlugs
     return (0, exports.getUnitLabelWithSlug)(unitToUse.unit_slug, locale, options.returnPlural, returnUnitForSlugs, options.returnShortByDefault);
 };
 exports.getProductUnitLabel = getProductUnitLabel;
+/**
+ * Returns the unit label for a specific slug
+ * @param {string} unitSlug The slug of the unit for which we want to get the label
+ * @param {string | undefined} locale The language in which we want to get the label
+ * @param {boolean} getPluralVersion Optionnal - If the plural version should be returned instead.
+ * @param {string[]} returnUnitForSlugs The slugs for which we want to return a default value, in this case the unit slug for unit
+ * @param {boolean} returnShortByDefault Optionnal - If the short version should be prioritized
+ */
 const getUnitLabelWithSlug = (unitSlug, locale = 'fr', getPluralVersion = false, returnUnitForSlugs, returnShortByDefault) => {
     if (!!returnUnitForSlugs && !!returnUnitForSlugs.includes(unitSlug)) {
         return (0, exports.getUnitLabelWithSlug)('unite', locale, getPluralVersion);
@@ -116,6 +146,13 @@ const getUnitLabelWithSlug = (unitSlug, locale = 'fr', getPluralVersion = false,
     return longVersion || shortVersion || unitSlug;
 };
 exports.getUnitLabelWithSlug = getUnitLabelWithSlug;
+/**
+ * Returns the plural unit label for a specific slug
+ * @deprecated Should use getUnitLabelWithSlug instead (with props getPluralVersion=true)
+ * @param {string} unitSlug The slug of the unit for which we want to get the label
+ * @param {string | undefined} locale The language in which we want to get the label
+ * @param {string[]} returnUnitForSlugs The slugs for which we want to return a default value, in this case the unit slug for unit
+ */
 const getPluralUnitLabelWithSlug = (unitSlug, locale = 'fr', returnUnitForSlugs, useShortIfDifferent) => {
     if (!!returnUnitForSlugs && !!returnUnitForSlugs.includes(unitSlug)) {
         return (0, locale_1.translateILang)(pluralSellUnitsBySlug['unite'], locale);
@@ -123,6 +160,7 @@ const getPluralUnitLabelWithSlug = (unitSlug, locale = 'fr', returnUnitForSlugs,
     const shortVersion = !!(0, inventories_1.getUnitShortDict)(unitSlug) ? (0, locale_1.translateILang)((0, inventories_1.getUnitShortDict)(unitSlug), locale) : '';
     const normalVersion = !!sellUnitsBySlug[unitSlug] ? (0, locale_1.translateILang)(sellUnitsBySlug[unitSlug], locale) : '';
     const pluralVersion = !!pluralSellUnitsBySlug[unitSlug] ? (0, locale_1.translateILang)(pluralSellUnitsBySlug[unitSlug], locale) : '';
+    // If useShowIfDifferent is defined, and short version is different from the "normal" version, return short value
     if (useShortIfDifferent && shortVersion != normalVersion)
         return shortVersion;
     return pluralVersion || shortVersion || unitSlug;
@@ -141,6 +179,10 @@ const productUnitSupportsDecimals = (unitSlug, isService) => {
     return !!isService || !!['p2', 'pl', 'vg3', 'tonne'].includes(unitSlug);
 };
 exports.productUnitSupportsDecimals = productUnitSupportsDecimals;
+// #endregion
+// ----------------------------------------------------------------------------------------------------------
+// ----------------------------------------------------------------------------------------------------------
+// #region GENERAL
 const getProductAttributes = (product) => {
     const arrColor = !!product.attributes[data_1.AttributesIdEnumGR.SUBCOLOR]
         ? product.attributes[data_1.AttributesIdEnumGR.SUBCOLOR]
@@ -169,6 +211,13 @@ const getDescriptionString = (showFullDesc, maxLength, description, locale = 'fr
     return truncated.join(' ') + ' [...]';
 };
 exports.getDescriptionString = getDescriptionString;
+/**
+ * Returns rounded product sell_unit quantities depending on current value, value of secondary input if existant and sale unit per command step ratio found in product.
+ * @param value {number} - Current quantity as entered by user in first input
+ * @param otherUnits {IFilledDimensionUnits[] | undefined} - FilledDimensionUnits found in product (possibly undefined)
+ * @param value2 {number | undefined} - Current quantity as entered by user in second input (possibly undefined)
+ * @param targetIsSecondaryInput {boolean} - If action was triggered from secondary input (defaults to false)
+ */
 const getRoundedSellUnitProductQuantities = (value, otherUnits = [], value2, targetIsSecondaryInput = false) => {
     var _a;
     const saleUnit = otherUnits.find((unit) => unit.is_sale_unit);
@@ -178,14 +227,18 @@ const getRoundedSellUnitProductQuantities = (value, otherUnits = [], value2, tar
         qte1: value,
         qte2: value2
     };
+    // Now rounds quantities in calculations to 2 or 0 decimals (depending on what the unit supports)
     if (!!targetIsSecondaryInput && typeof value2 === 'number') {
         if (!!commandStep && !!commandStep.fitting_unit && !!commandUnit && !!commandUnit.fitting_unit && !!saleUnit) {
             const nbCmdUnitPerCmdStep = (0, round_1.default)(commandStep.fitting_unit / commandUnit.fitting_unit, 5);
             const nbSaleUnitPerCmdStep = (0, round_1.default)(commandStep.fitting_unit / ((_a = saleUnit.fitting_unit) !== null && _a !== void 0 ? _a : 1), (0, exports.productUnitSupportsDecimals)(saleUnit.unit_slug) ? 5 : 0);
+            // Round value2 to command step
             const roundedValue = value2 === 0
                 ? 0
                 : _roundNbUnitPerCmdStep(value2, nbCmdUnitPerCmdStep, (0, exports.productUnitSupportsDecimals)(saleUnit.unit_slug) ? 2 : 0);
+            // Calculate amount of current command units by dividing roundedValue with nbCmdUnitPerCmdStep
             const nbOfRoundedCmdUnits = roundedValue / nbCmdUnitPerCmdStep;
+            // Then multiply result by amount of sale units in one command step
             const nbOfRoundedSaleUnits = nbOfRoundedCmdUnits * nbSaleUnitPerCmdStep;
             roundedQuantities = {
                 qte1: value2 === 0
@@ -207,8 +260,20 @@ const getRoundedSellUnitProductQuantities = (value, otherUnits = [], value2, tar
             if (value === 0) {
                 commandUnitQty = 0;
             }
+            // ** NOTE - Commented section here to fix rounding bug - Commented on 10-09-2025, in relation to bug GR-I540
+            // if sell_unit has a fitting unit of 1, we can simply divide the command_unit from roundedValue to get result
+            // else if (saleFittingUnit == 1) {
+            // 	console.log('YO YO YO are we HERE&&????')
+            // 	commandUnitQty = round(
+            // 		roundedValue / commandUnit.fitting_unit,
+            // 		productUnitSupportsDecimals(commandUnit.unit_slug) ? 2 : 0
+            // 	)
+            // }
             else {
+                // Calculate amount of current command steps by dividing roundedValue with saleUnitsPerCommandStep
+                // ** NOTE - Added round here on 10-09-2025 in relation to bug GR-I540
                 const nbOfCmdSteps = (0, round_1.default)(roundedValue / nbSaleUnitPerCmdStep, (0, exports.productUnitSupportsDecimals)(saleUnit.unit_slug) ? 5 : 0);
+                // Then multiply result by amount of command unit in one command step
                 commandUnitQty =
                     nbOfCmdSteps *
                         (0, round_1.default)(cmdStepFittingUnit / commandUnit.fitting_unit, (0, exports.productUnitSupportsDecimals)(commandUnit.unit_slug) ? 5 : 0);
@@ -223,6 +288,12 @@ const getRoundedSellUnitProductQuantities = (value, otherUnits = [], value2, tar
     return roundedQuantities;
 };
 exports.getRoundedSellUnitProductQuantities = getRoundedSellUnitProductQuantities;
+/**
+ * Returns rounded product quantities depending on current value per command step ratio found in product.
+ * @param value {number} - Current quantity as entered by user in first input
+ * @param otherUnits {IFilledDimensionUnits[] | undefined} - FilledDimensionUnits found in product (possibly undefined)
+ * @param type {'sale_unit' | 'inventory_unit'} - Quantity type for computing
+ */
 const getRoundedUnitProductQuantities = (value, otherUnits = [], type) => {
     const unitToTest = type == 'sale_unit'
         ? otherUnits.find((unit) => unit.is_sale_unit)
@@ -242,8 +313,9 @@ const getRoundedUnitProductQuantities = (value, otherUnits = [], type) => {
 };
 exports.getRoundedUnitProductQuantities = getRoundedUnitProductQuantities;
 const _roundNbUnitPerCmdStepV2 = (value, nbUnitPerCmdStep, decimalsToCheck = 0) => {
-    const currentFittingValue = (0, floor_1.default)(value / nbUnitPerCmdStep, 5);
+    const currentFittingValue = (0, floor_1.default)(value / nbUnitPerCmdStep, 5); // Rounds unsignificant quantities to lower value (ex. if result is 0.000007, we don't want it to round up to 1)
     const roundedUp = (0, round_1.default)((0, ceil_1.default)(currentFittingValue) * nbUnitPerCmdStep, decimalsToCheck);
+    // retrun roundedUp as default value.
     return roundedUp;
 };
 const _roundNbUnitPerCmdStep = (value, nbUnitPerCmdStep, decimalsToCheck = 0) => {
@@ -255,16 +327,29 @@ const _roundNbUnitPerCmdStep = (value, nbUnitPerCmdStep, decimalsToCheck = 0) =>
     }
     const rounded = (0, round_1.default)(value / nbUnitPerCmdStep, decimalsToCheck) * nbUnitPerCmdStep;
     const roundedUp = Math.ceil(value / nbUnitPerCmdStep) * nbUnitPerCmdStep;
+    // if rounded value is 0, but roundedUp is > 0, return roundedUp
     if (rounded == 0 && roundedUp > 0)
         return roundedUp;
+    // ** NEW - Added on 10-09-2025 in relation to bug GR-I540
+    // if provided value is already a multiple of cmdStep, return value
     if ((0, round_1.default)(value % nbUnitPerCmdStep, decimalsToCheck) == 0)
         return rounded;
+    // if provided value is larger than rounded, and roundedUp is an exact multiple of rounded, return roundedUp
     if ((0, round_1.default)(value, decimalsToCheck) > rounded + numberBuffer)
         return roundedUp;
+    // if rounded value is an exact multiple of cmdStep, return rounded
     if ((0, round_1.default)(rounded, decimalsToCheck) % nbUnitPerCmdStep <= numberBuffer)
         return rounded;
+    // retrun roundedUp as default value.
     return roundedUp;
 };
+/**
+ *
+ * @param {string} stringToSplit
+ * @param {string} dummyStringToReplace.currentValue, optionnal, default : '%%-%%'. Used to provide general replace values for a specific string. Is applied to both sections of the splitted string.
+ * @param {string} dummyStringToReplace.newValue, optionnal, default : ' - '. Used to provide general replace values for a specific string. Is applied to both sections of the splitted string.
+ * @returns {string[]}
+ */
 const splitOnDashes = (stringToSplit, dummyStringToReplace = { currentValue: '%%-%%', newValue: ' - ' }) => {
     let splited = stringToSplit.split(' - ');
     if (splited.length === 1)
@@ -279,6 +364,12 @@ const splitOnDashes = (stringToSplit, dummyStringToReplace = { currentValue: '%%
     ];
 };
 exports.splitOnDashes = splitOnDashes;
+/**
+ * Get product name as array. Array created mostly by splitting name on dash symbol (and variations).
+ * @param {IIndexedVariationAlgolia | IIndexedProduct} product
+ * @param {string | undefined} locale
+ * @returns {string[]} - Position 0 is the "commum section" of the name, and position 1 should contain all specifics (ex. color, size, etc...)
+ */
 const getProdName = (product, locale) => {
     let name;
     if (!!product.full_name) {
@@ -294,23 +385,33 @@ const getProdName = (product, locale) => {
     }
     let newNameArray = [];
     const dashesToFind = [' - ', '- ', ' -'];
+    // If name includes parenthesis...
     if (name.includes('(')) {
         let newStr = '';
         let strWithParenthesisToCheck = name;
+        // a. Replace all occurences of dashesToFind found between parenthesis with '-'
         while (strWithParenthesisToCheck.includes('(')) {
             let positionStart = strWithParenthesisToCheck.indexOf('(');
             let positionEnd = strWithParenthesisToCheck.indexOf(')');
+            // When first string between paranthesis found, replace dashesToFind
             let substrToCheck = strWithParenthesisToCheck.substring(positionStart, positionEnd + 1);
             for (let dash of dashesToFind) {
                 substrToCheck = substrToCheck.replace(dash, '-');
             }
+            // Add updated string to newStr from the beginning to the end of section with parenthesis
             newStr += strWithParenthesisToCheck.substring(0, positionStart) + substrToCheck;
+            // Strip checked string to remove section added to newStr.
+            // This will mean next time we go through the loop, logic will check for next section with parenthesis. If not found, loop ends.
             strWithParenthesisToCheck =
                 positionEnd === strWithParenthesisToCheck.length - 1 ? '' : strWithParenthesisToCheck.substring(positionEnd + 1);
         }
+        // Add ending of string to newly formatted string after loop done (in case last parenthesis found was not at the end of the string)
         newStr += strWithParenthesisToCheck;
+        // b. Isolate "first part" of string
         const positionOfFirst = newStr.indexOf(')');
         let firstPart = newStr.substring(0, positionOfFirst);
+        // If first closing parenthesis is not at end of string and firstPart contains dashesToFind, it means the ' - ' should be keep intact.
+        // Replace ' - ' found with uncommon string so we can put it back later, then call splitOnDashes function
         if (positionOfFirst !== newStr.length - 1 && dashesToFind.some((str) => firstPart.includes(str))) {
             const secondPart = newStr.substring(positionOfFirst);
             for (let str of dashesToFind) {
@@ -318,16 +419,22 @@ const getProdName = (product, locale) => {
             }
             newNameArray = (0, exports.splitOnDashes)(`${firstPart}${secondPart}`);
         }
+        // Else, simply call splitOnDashes function
         else {
             newNameArray = (0, exports.splitOnDashes)(newStr);
         }
     }
+    // Else, no parenthesis found, call splitOnDashes function
     else {
         newNameArray = (0, exports.splitOnDashes)(name);
     }
     return newNameArray;
 };
 exports.getProdName = getProdName;
+/**
+ * Function getParentProductCategoryGroup
+ * @param prod - Product to check
+ */
 const getParentProductCategoryGroup = (prod) => {
     let type = 'other';
     if (!!prod.categories && !!prod.categories['lvl0']) {
@@ -353,11 +460,18 @@ const getParentProductCategoryGroup = (prod) => {
     return type;
 };
 exports.getParentProductCategoryGroup = getParentProductCategoryGroup;
+/**
+ * Function getProductFormOptions - Returns all AttributeValues for product to construct options in add to cart form
+ * @param product - Product to check
+ * @param attributes - Array of IAttributes to fetch info from
+ */
 const getProductFormOptions = (product, attributes) => {
     let allColorOptions = [];
     let allDimensionOptions = [];
     let allFormatOptions = [];
+    //Product Attributes
     const product_attributes = (0, exports.getProductAttributes)(product);
+    //Overridden attr
     let overridenAttributes = product.declinations
         .map((declination) => declination.overriden_attributes)
         .filter((ova) => !!ova);
@@ -387,6 +501,8 @@ const getProductFormOptions = (product, attributes) => {
         }
         return finalOptions;
     };
+    // ----------------------------------------------------------
+    // #region colors
     const subColorsAttr = attributes.find((attr) => attr.id === data_1.AttributesIdEnumGR.SUBCOLOR);
     if (!!subColorsAttr) {
         const subColors = subColorsAttr.values;
@@ -394,6 +510,10 @@ const getProductFormOptions = (product, attributes) => {
         const finalColors = getOverriddenValues(colorsAttributes, data_1.AttributesIdEnumGR.SUBCOLOR);
         allColorOptions = (0, orderBy_1.default)(finalColors, (color) => product.declinations.findIndex((d) => d.attributes[data_1.AttributesIdEnumGR.SUBCOLOR].includes(color.slug)));
     }
+    // #endregion
+    // ----------------------------------------------------------
+    // ----------------------------------------------------------
+    // #region dimensions
     const dimensionsAttr = attributes.find((attr) => attr.id === data_1.AttributesIdEnumGR.DIMENSIONS);
     if (!!dimensionsAttr) {
         const dimensions = dimensionsAttr.values;
@@ -401,11 +521,17 @@ const getProductFormOptions = (product, attributes) => {
         const finalDimensions = getOverriddenValues(dimensionsAttributes, data_1.AttributesIdEnumGR.DIMENSIONS);
         allDimensionOptions = finalDimensions;
     }
+    // #endregion
+    // ----------------------------------------------------------
+    // ----------------------------------------------------------
+    // #region formats
     const formatsAttr = attributes.find((attr) => attr.id === data_1.AttributesIdEnumGR.FORMATS);
     if (!!formatsAttr) {
         const formats = formatsAttr.values;
         allFormatOptions = formats.filter((f) => product_attributes.formats.includes(f.slug));
     }
+    // #endregion
+    // ----------------------------------------------------------
     return {
         allColors: allColorOptions,
         allDimensions: allDimensionOptions,
@@ -413,6 +539,13 @@ const getProductFormOptions = (product, attributes) => {
     };
 };
 exports.getProductFormOptions = getProductFormOptions;
+/**
+ * @description Checks if product is of type by checking TYPE attribute value. Works with indexed product or cart item.
+ * @param product
+ * @param type
+ * @param excludeUndefined If excludeUndefined is true, products without the "type" attribute will return true
+ * @returns boolean
+ */
 const checkIfProductIsOfType = (product, type, excludeUndefined) => {
     const attr = !!product && !!product.attributes ? product.attributes : {};
     if (!!!attr[data_1.AttributesIdEnumGR.TYPE] && !!excludeUndefined)
@@ -422,15 +555,29 @@ const checkIfProductIsOfType = (product, type, excludeUndefined) => {
         attr[data_1.AttributesIdEnumGR.TYPE].includes(type));
 };
 exports.checkIfProductIsOfType = checkIfProductIsOfType;
+// #endregion
+// ----------------------------------------------------------------------------------------------------------
+// ----------------------------------------------------------------------------------------------------------
+// #region GRASS
 const checkIfProductIsInstallation = (item) => {
     return !!item.is_service && !!item.parent_slug && !!item.parent_slug.includes('installation');
 };
 exports.checkIfProductIsInstallation = checkIfProductIsInstallation;
+/**
+ * Returns array of installation items found in provided array
+ * @param items - Array of cart items or IIndexedDeclinations to check
+ */
 const getAllInstallFromItems = (items) => {
     return items.filter((i) => (!!i.parent_slug && products_2.installationProductsSlugs.includes(i.parent_slug)) ||
         Object.values(products_2.installationProSpecSkus).includes(i.sku));
 };
 exports.getAllInstallFromItems = getAllInstallFromItems;
+/**
+ * Function fuseGrassProducts
+ * @description - Returns items with only one apparent grass product (used for detail customers).
+ * ** FOR DISPLAY PURPOSES ONLY - Always save grass products separatly in ICart **
+ * @param recursiveItems - ICartItems with subitems (object created for display purposes)
+ */
 const fuseGrassProducts = (recursiveItems, isPro) => {
     const specialityGrass = recursiveItems[0];
     const kentuckyGrass = (specialityGrass.sub_items || []).find((sub) => sub.sku === products_2.kentucky);
@@ -490,6 +637,7 @@ const getMinQtyFeeText = (parent_slug = '', grassProduct, isPro, locale = 'fr',
         fr: ` Ce frais correspond au prix du gazon choisi multiplié par la différence entre la quantité choisie et le minimum.`,
         en: ` Ce frais correspond au prix du gazon choisi multiplié par la différence entre la quantité choisie et le minimum.`
     }, locale);
+    // If expedition method not chosen yet, and pickup & shipping quantities are different, show both
     if (!!!expeditionMethod && type === 'order' && minQuantities.pickup !== minQuantities.shipping) {
         const strMinShipping = `${minQuantities.shipping}${localeSellUnit} (${minQuantities.shipping / 740} ${localeMinUnit})`;
         const strMinPickup = !!minQuantities.pickup
@@ -504,6 +652,7 @@ const getMinQtyFeeText = (parent_slug = '', grassProduct, isPro, locale = 'fr',
         }
         return str;
     }
+    // Show specific quantity for expedition type
     const minBillableQty = type === 'install'
         ? minQuantities.install
         : expeditionMethod === 'pickup'
@@ -586,6 +735,12 @@ const getGrassSubQuestionsByType = (type) => {
     return products_2.otherGrassSubQuestions.filter((sub) => 'installation-gazon' === sub.associatedProductSlug || (!!sub.installOnly && !!!sub.proOnly));
 };
 exports.getGrassSubQuestionsByType = getGrassSubQuestionsByType;
+/**
+ * @description For grass products. Over 1480pi2, if installation, quantities are rounded to rolls (10pi2) if pickup, and to half pal. if shipping
+ * @param grassProduct
+ * @param cartData
+ * @returns quantity rounded to rolls with items to change or undefined
+ */
 const handleGrassProductQtyRoundForShipping = (cartData, grassProduct) => {
     if (!!!cartData || !!!grassProduct)
         return;
@@ -595,10 +750,12 @@ const handleGrassProductQtyRoundForShipping = (cartData, grassProduct) => {
     const productOtherUnits = product.other_units;
     if (!!!productOtherUnits)
         return;
+    // get new rounded qte
     const palUnit = productOtherUnits.find((u) => u.unit_slug === 'pal');
     const rounded = (0, exports.roundGrassQte)(product.qte, !!!cartData.is_pickup, palUnit);
     if (!!!rounded || rounded === grassProduct.qte)
         return;
+    // ajust items with new quantity
     let itemsToChange = [];
     const recursiveGrassItem = (0, cart_1.getRecursiveItems)(cartData.items).find((item) => item.sku === grassProduct.sku);
     const getItemsToChange = (item) => {
@@ -647,6 +804,13 @@ const handleGrassProductQtyRoundForShipping = (cartData, grassProduct) => {
     return { rounded, itemsToChange };
 };
 exports.handleGrassProductQtyRoundForShipping = handleGrassProductQtyRoundForShipping;
+/**
+ * Function roundGrassQte
+ * @description Returns rounded grass quantity depending on current qty, if customer selected installation and pallet unit (if defined)
+ * @param currentQte {number} - Current quantity as entered by user in input
+ * @param isShipping {boolean} - Whether customer has selected installation option
+ * @param palUnit {IFilledDimensionUnits | undefined} - Pallet FilledDimensionUnit (possibly undefined)
+ */
 const roundGrassQte = (currentQte, isShipping, palUnit) => {
     let newQte = currentQte;
     switch (true) {
@@ -680,6 +844,11 @@ const roundGrassQte = (currentQte, isShipping, palUnit) => {
     return newQte;
 };
 exports.roundGrassQte = roundGrassQte;
+/**
+ * Detects if customer has "Installation tout inclus".
+ * @param customPriceList - Customer custom price list
+ * @return All inclusive installation if exists, undefined otherwise
+ */
 const getInstallationAllInclusiveFromPriceList = (customPriceList) => {
     if (!!!customPriceList || !!!customPriceList.length)
         return;
@@ -690,10 +859,22 @@ const getInstallationAllInclusiveFromPriceList = (customPriceList) => {
     return item;
 };
 exports.getInstallationAllInclusiveFromPriceList = getInstallationAllInclusiveFromPriceList;
+/**
+ * Checks if all-inclusive installation is active.
+ * @param hasInstallation - Whether the cart/form contains an installation
+ * @param isPro - Whether the customer is a pro
+ * @param customPriceList - Customer custom price list
+ * @returns true if all-inclusive installation is active
+ */
 const isInstallAllInclusiveActive = (hasInstallation, isPro, customPriceList) => {
     return !!hasInstallation && !!isPro && !!(0, exports.getInstallationAllInclusiveFromPriceList)(customPriceList);
 };
 exports.isInstallAllInclusiveActive = isInstallAllInclusiveActive;
+/**
+ * Force )$ to kentucky base grass and sod delivery fee if install all-inclusive.
+ * @param item - The cart item to potentially override
+ * @returns The item with zeroed price if applicable, or the original item
+ */
 const applyAllInclusiveOverrides = (item) => {
     const isKentucky = item.parent_slug === 'kentucky' || item.sku === products_2.kentucky;
     const isSodDelivery = item.parent_slug === 'livraison-gazon' && products_2.sodDeliverySkus.includes(item.sku);
@@ -703,17 +884,21 @@ const applyAllInclusiveOverrides = (item) => {
     return item;
 };
 exports.applyAllInclusiveOverrides = applyAllInclusiveOverrides;
+// Determines if a cart item should be hidden from checkout display. Used for all-inclusive installation
 const shouldHideItemInCheckout = (item, allItems) => {
     const hasAllInclusive = allItems.some((i) => i.sku === products_2.installationAllInclusiveSku);
     if (!hasAllInclusive)
         return false;
     if (item.regular_price.amount !== 0)
         return false;
+    // Hide installation upsells at $0 (mobilisation, fertilisation, roulage, etc.)
     const installationSkus = allItems.filter((i) => i.parent_slug === 'installation-gazon').map((i) => i.sku);
     if (!!item.is_upsell_of_sku && installationSkus.includes(item.is_upsell_of_sku))
         return true;
+    // Hide sod delivery at $0
     if (item.parent_slug === 'livraison-gazon')
         return true;
+    // Hide installation surcharges at $0 (e.g. surcharge mobilisation île de Montréal)
     if (item.parent_slug === 'surcharges-installation-gazon')
         return true;
     return false;
@@ -728,6 +913,8 @@ const getInstallationArray = async (qte, baseGrassUpsells, fetchProduct, locale,
     const installation_parent = await fetchProduct('installation-gazon', locale, true, true);
     let installation_decli;
     const minQteInstall = (0, expedition_1.getMinQteInstall)(isPro);
+    // Variable pour vérifier si une déclinaison d'installation existe déjà dans le cart
+    // ** Utile pour la modification des items du cart, vu que la props is_upsell_of_sku ne peut pas se modifier on update
     let arrayFinal = [];
     if (!!installation_parent && !!installation_upsell && !!installation_upsell.length) {
         let installation_array = [];
@@ -745,8 +932,11 @@ const getInstallationArray = async (qte, baseGrassUpsells, fetchProduct, locale,
         const closestQte = (0, maxBy_1.default)(installation_qte_array.filter((upsell) => {
             return upsell.actual_qty <= qte;
         }), 'actual_qty');
+        // MODIFS. FRAIS 2024 - On n'ajoute pas les frais au panier si leur prix régulier est de 0.00$
+        // Vérification faite à chaque ajout de déclinaison au arrayFinal
         if (!!closestQte) {
             installation_decli = installation_parent.declinations.find((decli) => decli.sku === closestQte.recommendation_sku);
+            // Check if customer has installation all-inclusive
             const allInclusivePriceItem = !!isPro && !!customPriceList ? (0, exports.getInstallationAllInclusiveFromPriceList)(customPriceList) : undefined;
             if (!!installation_decli) {
                 const allInclusiveDecli = !!allInclusivePriceItem && !!installation_parent
@@ -761,10 +951,12 @@ const getInstallationArray = async (qte, baseGrassUpsells, fetchProduct, locale,
                         installation_decli = (0, g2_1.checkForCustomPriceEquivalent)(installation_decli, customPriceList);
                     }
                 }
+                // Add the correct installation option depending on whether the customer has "Installation tout inclus"
                 if (!(0, exports.shouldHideItemIfRegPriceIs0)(installation_decli, installation_parent.slug)) {
                     arrayFinal.push(Object.assign(Object.assign({}, installation_decli), { parent_slug: 'installation-gazon', qte: qte, is_upsell_of_sku: chosenSku, product_upsells: installation_parent.product_upsells }));
                 }
             }
+            // Frais minimum d'installation
             if (qte < minQteInstall) {
                 const minimum_installation_fee = await fetchProduct('frais-minimum-gazon-pour-installation', locale, true, true);
                 if (!!minimum_installation_fee) {
@@ -778,6 +970,7 @@ const getInstallationArray = async (qte, baseGrassUpsells, fetchProduct, locale,
                     }
                 }
             }
+            // Frais de mobilisation (pour l'installation)
             const mobilisation_fee = await fetchProduct('frais-de-mobilisation', locale, true, true);
             if (!!mobilisation_fee && !!isPro) {
                 let mobilisationDecli = mobilisation_fee.declinations[0];
@@ -790,8 +983,11 @@ const getInstallationArray = async (qte, baseGrassUpsells, fetchProduct, locale,
                             : minQteInstall / (740 * expedition_1.installationFeePalletTier)), is_upsell_of_sku: installation_decli.sku, product_upsells: mobilisation_fee.product_upsells }));
                 }
             }
+            // -----------------------------------------------------------------------
+            // AUTRES FRAIS CONNEXES
             if (!!returnOtherFees) {
                 if (!!returnOtherFees.engrais) {
+                    // fertilisation
                     const fertilisation = await fetchProduct('installation-fertilisation', locale, true, true);
                     if (!!fertilisation) {
                         let minFertilisationDecli = fertilisation.declinations[0];
@@ -804,6 +1000,7 @@ const getInstallationArray = async (qte, baseGrassUpsells, fetchProduct, locale,
                     }
                 }
                 if (returnOtherFees.roulage) {
+                    // roullage
                     const roullage = await fetchProduct('installation-roulage', locale, true, true);
                     if (!!roullage) {
                         let minRoulageDecli = roullage.declinations[0];
@@ -840,6 +1037,10 @@ const getInstallItemPrice = (parentSlug, servicesFees) => {
     return price;
 };
 exports.getInstallItemPrice = getInstallItemPrice;
+// #endregion
+// ----------------------------------------------------------------------------------------------------------
+// ----------------------------------------------------------------------------------------------------------
+// #region CONCRETE
 const getConcreteQteText = (declination, locale = 'fr') => {
     let txt = '';
     if (!!!declination)
@@ -868,6 +1069,7 @@ const getConcreteQteText = (declination, locale = 'fr') => {
             nbSaleUnitsPerCmdStep = !!cmdSameAsSale
                 ? commandStep.fitting_unit / commandUnit.fitting_unit
                 : commandStep.fitting_unit / saleUnit.fitting_unit;
+            // Round at correct decimals for products where commandStep.fitting_unit is 1 (meaning value calculated before is correct sell units per step)
             nbUnitsPerPal =
                 commandStep.fitting_unit == 1 && !!!commandStep.is_sale_unit
                     ? unitsPerPal.fitting_unit *
@@ -894,6 +1096,11 @@ const getConcreteQteText = (declination, locale = 'fr') => {
     return txt;
 };
 exports.getConcreteQteText = getConcreteQteText;
+/**
+ * @description returns all items in cart where attribute AVAILABILITY contains wanted type.
+ * @param cartData
+ * @param availabilityType
+ */
 const getConcreteItemsByAvailability = (cartData, availabilityType, returnTrueIfUndefined) => {
     return cartData.items.filter((i) => {
         return ((i.attributes[data_1.AttributesIdEnumGR.AVAILABILITY] &&
@@ -902,8 +1109,21 @@ const getConcreteItemsByAvailability = (cartData, availabilityType, returnTrueIf
     });
 };
 exports.getConcreteItemsByAvailability = getConcreteItemsByAvailability;
+// #endregion
+// ----------------------------------------------------------------------------------------------------------
+// ----------------------------------------------------------------------------------------------------------
+// #region VRAC
+/**
+ * Function getVracType - constructs vrac helper object is cart contains vrac or vrac associated items.
+ * @param stores
+ * @param cartData
+ * @param getInventoryItemCallback
+ * @param inventoryItemArray
+ * @returns IVracType object containing vrac_type enum value and vrac_store_ids where vrac items are available
+ */
 const getVracType = async (stores, cartData, getInventoryItemCallback, inventoyItemArray) => {
     const items = cartData.items;
+    // If cart does not contain vrac or vrac-agacent accessories (.is_other_type==='vrac)), return
     if (!!!items ||
         !!!items.length ||
         (!!!(0, cart_1.checkIfCartContainsType)(cart_2.CartGeneralTypeEnum.VRAC, cartData) &&
@@ -944,6 +1164,31 @@ const getVracType = async (stores, cartData, getInventoryItemCallback, inventoyI
     }
 };
 exports.getVracType = getVracType;
+// #endregion
+// ----------------------------------------------------------------------------------------------------------
+// ----------------------------------------------------------------------------------------------------------
+// #region FEES
+/**
+ * Get all possible fees for a cart with basic info, to show approx. fee total before all data is saved in cart
+ *
+ * @param useFees If local fee array should be used, to save database calls
+ * @param newCart Current cart data
+ * @param deliveryType If fees should be checked for a pick-up or shipping order
+ * @param fetchProduct Callback function for product fetch
+ * @param getIfAddressIsInsideZones Callback function for zone check
+ * @param getDistanceFromAddress Callback function to check distance with provided address
+ * @param locale User's locale (fr or en)
+ * @param allStores Full store array for space
+ * @param isPro If customer associated with cart is a pro customer
+ * @param grassProduct Constructed grass product from cart (with extra data for checks)
+ * @param concreteOrder Constructed concrete products from cart (with extra data for checks)
+ * @param settings.addOnePalletToPickup Optionnal - If additionnal pal. should be added for order
+ * @param settings.saveToShippingPayload Optional - If data collected should be saved to cart's shipping_payload
+ * @param settings.useStoreAddress Optionnal - Provided store ID for which the address should be used for check
+ * @param settings.useDeliveryAddress Optionnal - If current carts shipping address should be used for check
+ * @param settings.useAvailableVracStores Optionnal - Provided array of store IDs available for vrac order
+ * @param customPriceList Optionnal - If pro customer with G2 custom price list and custom prices should be checked
+ */
 const fetchFeesBeforeCart = async (useFees, newCart, deliveryType, fetchProduct, getIfAddressIsInsideZones, getDistanceFromAddress, locale, allStores, isPro, grassProduct, concreteOrder, settings, customPriceList) => {
     const cartContainsVrac = (0, cart_1.checkIfCartContainsType)(cart_2.CartGeneralTypeEnum.VRAC, newCart);
     const cartContainsInstallation = (0, cart_1.checkIfCartContainsType)(cart_2.CartGeneralTypeEnum.INSTALLATION, newCart);
@@ -960,14 +1205,27 @@ const fetchFeesBeforeCart = async (useFees, newCart, deliveryType, fetchProduct,
                 : undefined, locale, undefined, false, cartContainsAccessoriesOnly, undefined, allStores, customPriceList, !!useFees);
 };
 exports.fetchFeesBeforeCart = fetchFeesBeforeCart;
+// #endregion
+// ----------------------------------------------------------------------------------------------------------
+// ----------------------------------------------------------------------------------------------------------
+// #region PRO SPECIFICITIES
+/**
+ * Check if pro custom promo info should be shown for customer for a specific product.
+ * @param userData
+ * @param isPro
+ * @param product
+ * @param customMinPrice
+ */
 const shouldShowProCustomPromo = (userData, isPro, product, customMinPrice) => {
     if (!!!product || !!!isPro || !!!userData)
         return false;
+    // If customMinPrice is defined (meaning customer has custom price list), and the price type is not REG or has type NET, always return true
     if (!!customMinPrice) {
         if (customMinPrice.type === G2_1.CustomPriceItemTypeEnum.REG && customMinPrice.code2 !== 'NET')
             return false;
         return true;
     }
+    // Check customer group. If promo exists and should apply for customer group, return true
     const customerGroup = (0, object_1.recursiveCheckObject)(userData, 'userData.basic_info.customer_professionnal_info.external_customer_group');
     const customerType = !!customerGroup ? (0, g2_1.getG2CustomerTypeFromCode)(customerGroup) : undefined;
     const prodPriceClass = !!product.price_classes_range
@@ -1014,22 +1272,35 @@ const applyProCustomPromo = (decli, userData) => {
     };
 };
 exports.applyProCustomPromo = applyProCustomPromo;
+// Indexed products - Custom prices if pro
 const getFormattedProdGR = (decli, productSlug, isPro) => {
     const { promo_price, discount_price, tier_pricing } = decli, rest = __rest(decli, ["promo_price", "discount_price", "tier_pricing"]);
     return !!isPro ? Object.assign(Object.assign({}, rest), (productSlug !== 'kentucky' ? { tier_pricing } : {})) : decli;
 };
 exports.getFormattedProdGR = getFormattedProdGR;
+/**
+ * Checks if a 0.00$ reg_price item should be considered "hidden" or not.
+ * @param item - The indexedDecli or cartItem to check
+ * @param productSlug - The parent product's slug (in case it is not found in item)
+ * @param isUpsellOfInstallProd - Optionnal. If item is upsell of install product (additionnal fee for installation)
+ */
 const shouldHideItemIfRegPriceIs0 = (item, productSlug, isUpsellOfInstallProd) => {
+    // A. Check if reg price is 0. If not, should not hide item
     const regPriceIs0 = item.regular_price.amount == 0;
     if (!regPriceIs0)
         return false;
+    // B. Check if item is fee or service. If not, should not hide item
     if (!item.is_service)
         return false;
+    // C. Check if item is an upsell of an installation product (additionnal install fees). If so, should not hide item
     if (!!isUpsellOfInstallProd)
         return false;
+    // D. Check if item is a shipping fee. If so, should not hide item
     if (expedition_1.slugsToCheckFromExpeditionFees.shipping.includes(productSlug))
         return false;
     return true;
 };
 exports.shouldHideItemIfRegPriceIs0 = shouldHideItemIfRegPriceIs0;
+// #endregion
+// ----------------------------------------------------------------------------------------------------------
 //# sourceMappingURL=products.js.map