@tmlmt/cooklang-parser 3.0.0-alpha.11 → 3.0.0-alpha.13

package/dist/index.js

@@ -265,6 +265,12 @@ var i = (() => {
 })();
 
 // src/regex.ts
+var metadataKeyRegex = /^([^:\n]+?):/gm;
+var numericValueRegex = /^-?\d+(\.\d+)?$/;
+var nestedMetaVarRegex = (varName) => new RegExp(
+  `^${varName}:\\s*\\r?\\n((?:[ ]+.+(?:\\r?\\n|$))+)`,
+  "m"
+);
 var metadataRegex = d().literal("---").newline().startCaptureGroup().anyCharacter().zeroOrMore().optional().endGroup().newline().literal("---").dotAll().toRegExp();
 var scalingMetaValueRegex = (varName) => d().startAnchor().literal(varName).literal(":").anyOf("\\t ").zeroOrMore().startCaptureGroup().startCaptureGroup().notAnyOf(",\\n").oneOrMore().endGroup().startGroup().literal(",").whitespace().zeroOrMore().startCaptureGroup().anyCharacter().oneOrMore().endGroup().endGroup().optional().endGroup().endAnchor().multiline().toRegExp();
 var nonWordChar = "\\s@#~\\[\\]{(,;:!?";
@@ -876,6 +882,20 @@ var InvalidQuantityFormat = class extends Error {
     this.name = "InvalidQuantityFormat";
   }
 };
+var NoTabAsIndentError = class extends Error {
+  constructor() {
+    super(
+      `Tabs are not allowed for indentation in metadata blocks. Please use spaces only.`
+    );
+    this.name = "NoTabAsIndentError";
+  }
+};
+var BadIndentationError = class extends Error {
+  constructor() {
+    super(`Bad identation of a nested block. Please use spaces only.`);
+    this.name = "BadIndentationError";
+  }
+};
 
 // src/utils/type_guards.ts
 function isGroup(x) {
@@ -1433,6 +1453,108 @@ function parseListMetaVar(content, varName) {
     return listMatch[2].split("\n").filter((line) => line.trim() !== "").map((line) => line.replace(/^\s*-\s*/, "").trim());
   }
 }
+function extractAllMetadataKeys(content) {
+  const keys = [];
+  for (const match of content.matchAll(metadataKeyRegex)) {
+    keys.push(match[1].trim());
+  }
+  return [...new Set(keys)];
+}
+function parseNestedMetaVar(content, varName) {
+  const match = content.match(nestedMetaVarRegex(varName));
+  if (!match) return void 0;
+  const nestedContent = match[1];
+  return parseNestedBlock(nestedContent);
+}
+function parseNestedBlock(content) {
+  const lines = content.split(/\r?\n/).filter((line) => line.trim() !== "");
+  if (lines.length === 0) return void 0;
+  const baseIndentMatch = lines[0].match(/^(\s*)/);
+  if (baseIndentMatch?.[0]?.includes("	")) {
+    throw new NoTabAsIndentError();
+  }
+  const baseIndent = baseIndentMatch?.[1]?.length;
+  if (lines[0].trim().startsWith("- ")) return void 0;
+  const result = {};
+  let i2 = 0;
+  while (i2 < lines.length) {
+    const line = lines[i2];
+    const leadingWhitespace = line.match(/^(\s*)/)?.[1];
+    if (leadingWhitespace && leadingWhitespace.includes("	")) {
+      throw new NoTabAsIndentError();
+    }
+    const currentIndent = leadingWhitespace.length;
+    if (currentIndent < baseIndent) {
+      break;
+    }
+    if (currentIndent !== baseIndent) {
+      throw new BadIndentationError();
+    }
+    const keyValueMatch = line.match(/^[ ]*([^:\n]+?):\s*(.*)$/);
+    if (!keyValueMatch) {
+      i2++;
+      continue;
+    }
+    const key = keyValueMatch[1].trim();
+    const rawValue = keyValueMatch[2].trim();
+    if (rawValue === "") {
+      const childLines = [];
+      let j = i2 + 1;
+      while (j < lines.length) {
+        const childLine = lines[j];
+        const childIndent = childLine.match(/^([ ]*)/)?.[1]?.length;
+        if (childIndent && childIndent > baseIndent) {
+          childLines.push(childLine);
+          j++;
+        } else {
+          break;
+        }
+      }
+      if (childLines.length > 0) {
+        const firstChildTrimmed = childLines[0].trim();
+        if (firstChildTrimmed.startsWith("- ")) {
+          const reconstructedContent = `${key}:
+${childLines.join("\n")}`;
+          const listResult = parseListMetaVar(reconstructedContent, key);
+          if (listResult) {
+            result[key] = listResult.map(
+              (item) => parseMetadataValue(item)
+            );
+          }
+        } else {
+          const childContent = childLines.join("\n");
+          const nested = parseNestedBlock(childContent);
+          if (nested) {
+            result[key] = nested;
+          }
+        }
+      }
+      i2 = j;
+    } else {
+      result[key] = parseMetadataValue(rawValue);
+      i2++;
+    }
+  }
+  return result;
+}
+function parseMetadataValue(rawValue) {
+  if (rawValue.startsWith("[") && rawValue.endsWith("]")) {
+    return rawValue.slice(1, -1).split(",").map((item) => item.trim());
+  }
+  if (numericValueRegex.test(rawValue)) {
+    return Number(rawValue);
+  }
+  return rawValue;
+}
+function parseAnyMetaVar(content, varName) {
+  const nested = parseNestedMetaVar(content, varName);
+  if (nested) return nested;
+  const list = parseListMetaVar(content, varName);
+  if (list) return list;
+  const simple = parseSimpleMetaVar(content, varName);
+  if (simple) return parseMetadataValue(simple);
+  return void 0;
+}
 function extractMetadata(content) {
   const metadata = {};
   let servings = void 0;
@@ -1440,13 +1562,24 @@ function extractMetadata(content) {
   if (!metadataContent) {
     return { metadata };
   }
-  for (const metaVar of [
+  const handledKeys = /* @__PURE__ */ new Set([
+    // Simple string fields
     "title",
+    "author",
+    "locale",
+    "introduction",
+    "description",
+    "course",
+    "category",
+    "diet",
+    "cuisine",
+    "difficulty",
+    // Source fields
     "source",
     "source.name",
     "source.url",
-    "author",
     "source.author",
+    // Time fields
     "prep time",
     "time.prep",
     "cook time",
@@ -1454,6 +1587,23 @@ function extractMetadata(content) {
     "time required",
     "time",
     "duration",
+    // Image fields
+    "image",
+    "picture",
+    "images",
+    "pictures",
+    // Unit system
+    "unit system",
+    // Scaling fields
+    "servings",
+    "yield",
+    "serves",
+    // List fields
+    "tags"
+  ]);
+  for (const metaVar of [
+    "title",
+    "author",
     "locale",
     "introduction",
     "description",
@@ -1461,17 +1611,57 @@ function extractMetadata(content) {
     "category",
     "diet",
     "cuisine",
-    "difficulty",
-    "image",
-    "picture"
+    "difficulty"
   ]) {
     const stringMetaValue = parseSimpleMetaVar(metadataContent, metaVar);
     if (stringMetaValue) metadata[metaVar] = stringMetaValue;
   }
+  const sourceNested = parseNestedMetaVar(metadataContent, "source");
+  const sourceTxt = parseSimpleMetaVar(metadataContent, "source");
+  const sourceName = parseSimpleMetaVar(metadataContent, "source.name");
+  const sourceUrl = parseSimpleMetaVar(metadataContent, "source.url");
+  const sourceAuthor = parseSimpleMetaVar(metadataContent, "source.author");
+  if (sourceNested) {
+    const source = {};
+    if (typeof sourceNested.name === "string") source.name = sourceNested.name;
+    if (typeof sourceNested.url === "string") source.url = sourceNested.url;
+    if (typeof sourceNested.author === "string")
+      source.author = sourceNested.author;
+    if (Object.keys(source).length > 0) metadata.source = source;
+  } else if (sourceName || sourceAuthor || sourceUrl) {
+    const source = {};
+    if (sourceName) source.name = sourceName;
+    if (sourceUrl) source.url = sourceUrl;
+    if (sourceAuthor) source.author = sourceAuthor;
+    metadata.source = source;
+  } else if (sourceTxt) {
+    metadata.source = sourceTxt;
+  }
+  const timeNested = parseNestedMetaVar(metadataContent, "time");
+  const prepTime = parseSimpleMetaVar(metadataContent, "prep time") ?? parseSimpleMetaVar(metadataContent, "time.prep");
+  const cookTime = parseSimpleMetaVar(metadataContent, "cook time") ?? parseSimpleMetaVar(metadataContent, "time.cook");
+  const totalTime = parseSimpleMetaVar(metadataContent, "time required") ?? parseSimpleMetaVar(metadataContent, "time") ?? parseSimpleMetaVar(metadataContent, "duration");
+  if (timeNested) {
+    const time = {};
+    if (typeof timeNested.prep === "string") time.prep = timeNested.prep;
+    if (typeof timeNested.cook === "string") time.cook = timeNested.cook;
+    if (typeof timeNested.total === "string") time.total = timeNested.total;
+    if (Object.keys(time).length > 0) metadata.time = time;
+  } else if (prepTime || cookTime || totalTime) {
+    const time = {};
+    if (prepTime) time.prep = prepTime;
+    if (cookTime) time.cook = cookTime;
+    if (totalTime) time.total = totalTime;
+    metadata.time = time;
+  }
+  const image = parseSimpleMetaVar(metadataContent, "image") ?? parseSimpleMetaVar(metadataContent, "picture");
+  if (image) metadata.image = image;
+  const images = parseListMetaVar(metadataContent, "images") ?? parseListMetaVar(metadataContent, "pictures");
+  if (images) metadata.images = images;
   let unitSystem;
   const unitSystemRaw = parseSimpleMetaVar(metadataContent, "unit system");
   if (unitSystemRaw) {
-    metadata["unit system"] = unitSystemRaw;
+    metadata.unitSystem = unitSystemRaw;
     const unitSystemMap = {
       metric: "metric",
       us: "US",
@@ -1480,16 +1670,22 @@ function extractMetadata(content) {
     };
     unitSystem = unitSystemMap[unitSystemRaw.toLowerCase()];
   }
-  for (const metaVar of ["serves", "yield", "servings"]) {
+  for (const metaVar of ["servings", "yield", "serves"]) {
     const scalingMetaValue = parseScalingMetaVar(metadataContent, metaVar);
     if (scalingMetaValue && scalingMetaValue[1]) {
       metadata[metaVar] = scalingMetaValue[1];
       servings = scalingMetaValue[0];
     }
   }
-  for (const metaVar of ["tags", "images", "pictures"]) {
-    const listMetaValue = parseListMetaVar(metadataContent, metaVar);
-    if (listMetaValue) metadata[metaVar] = listMetaValue;
+  const tags = parseListMetaVar(metadataContent, "tags");
+  if (tags) metadata.tags = tags;
+  const allKeys = extractAllMetadataKeys(metadataContent);
+  for (const key of allKeys) {
+    if (handledKeys.has(key)) continue;
+    const value = parseAnyMetaVar(metadataContent, key);
+    if (value !== void 0) {
+      metadata[key] = value;
+    }
   }
   return { metadata, servings, unitSystem };
 }
@@ -2235,7 +2431,7 @@ var _Recipe = class _Recipe {
         alternative.note = note;
       }
       if (itemQuantity) {
-        alternative.itemQuantity = itemQuantity;
+        Object.assign(alternative, itemQuantity);
       }
       alternatives.push(alternative);
       testString = groups.ingredientAlternative || "";
@@ -2343,7 +2539,7 @@ var _Recipe = class _Recipe {
       displayName
     };
     if (itemQuantity) {
-      alternative.itemQuantity = itemQuantity;
+      Object.assign(alternative, itemQuantity);
     }
     const existingAlternatives = this.choices.ingredientGroups.get(groupKey);
     function upsertAlternativeToIngredient(ingredients, ingredientIdx, newAlternativeIdx) {
@@ -2390,7 +2586,7 @@ var _Recipe = class _Recipe {
    * Quantities are grouped by their alternative signature and summed using addEquivalentsAndSimplify.
    * @internal
    */
-  _populate_ingredient_quantities() {
+  _populateIngredientQuantities() {
     for (const ing of this.ingredients) {
       delete ing.quantities;
       delete ing.usedAsPrimary;
@@ -2479,28 +2675,28 @@ var _Recipe = class _Recipe {
           for (const alt of allAlts) {
             referencedIndices.add(alt.index);
           }
-          if (!alternative.itemQuantity) continue;
+          if (!alternative.quantity) continue;
           const baseQty = {
-            quantity: alternative.itemQuantity.quantity,
-            ...alternative.itemQuantity.unit && {
-              unit: alternative.itemQuantity.unit
+            quantity: alternative.quantity,
+            ...alternative.unit && {
+              unit: alternative.unit
             }
           };
-          const quantityEntry = alternative.itemQuantity.equivalents?.length ? { or: [baseQty, ...alternative.itemQuantity.equivalents] } : baseQty;
+          const quantityEntry = alternative.equivalents?.length ? { or: [baseQty, ...alternative.equivalents] } : baseQty;
           let alternativeRefs;
           if (!hasExplicitChoice && allAlts.length > 1) {
             alternativeRefs = allAlts.filter(
               (alt) => isGrouped ? alt.itemId !== item.id : alt.index !== alternative.index
             ).map((otherAlt) => {
               const ref = { index: otherAlt.index };
-              if (otherAlt.itemQuantity) {
+              if (otherAlt.quantity) {
                 const altQty = {
-                  quantity: otherAlt.itemQuantity.quantity,
-                  ...otherAlt.itemQuantity.unit && {
-                    unit: otherAlt.itemQuantity.unit.name
+                  quantity: otherAlt.quantity,
+                  ...otherAlt.unit && {
+                    unit: otherAlt.unit.name
                   },
-                  ...otherAlt.itemQuantity.equivalents && {
-                    equivalents: otherAlt.itemQuantity.equivalents.map(
+                  ...otherAlt.equivalents && {
+                    equivalents: otherAlt.equivalents.map(
                       (eq) => toPlainUnit(eq)
                     )
                   }
@@ -2513,14 +2709,10 @@ var _Recipe = class _Recipe {
           const altIndices = getAlternativeSignature(alternativeRefs) ?? "";
           let signature;
           if (isGrouped) {
-            const resolvedUnit = resolveUnit(
-              alternative.itemQuantity.unit?.name
-            );
+            const resolvedUnit = resolveUnit(alternative.unit?.name);
             signature = `group:${item.group}|${altIndices}|${resolvedUnit.type}`;
           } else if (altIndices) {
-            const resolvedUnit = resolveUnit(
-              alternative.itemQuantity.unit?.name
-            );
+            const resolvedUnit = resolveUnit(alternative.unit?.name);
             signature = `${altIndices}|${resolvedUnit.type}}`;
           } else {
             signature = null;
@@ -2755,7 +2947,7 @@ var _Recipe = class _Recipe {
     if (!section.isBlank()) {
       this.sections.push(section);
     }
-    this._populate_ingredient_quantities();
+    this._populateIngredientQuantities();
   }
   /**
    * Scales the recipe to a new number of servings. In practice, it calls
@@ -2788,16 +2980,16 @@ var _Recipe = class _Recipe {
     const unitSystem = this.unitSystem;
     function scaleAlternativesBy(alternatives, factor2) {
       for (const alternative of alternatives) {
-        if (alternative.itemQuantity) {
-          const scaleFactor = alternative.itemQuantity.scalable ? Big4(factor2) : 1;
-          if (alternative.itemQuantity.quantity.type !== "fixed" || alternative.itemQuantity.quantity.value.type !== "text") {
-            alternative.itemQuantity.quantity = multiplyQuantityValue(
-              alternative.itemQuantity.quantity,
+        if (alternative.quantity) {
+          const scaleFactor = alternative.scalable ? Big4(factor2) : 1;
+          if (alternative.quantity.type !== "fixed" || alternative.quantity.value.type !== "text") {
+            alternative.quantity = multiplyQuantityValue(
+              alternative.quantity,
               scaleFactor
             );
           }
-          if (alternative.itemQuantity.equivalents) {
-            alternative.itemQuantity.equivalents = alternative.itemQuantity.equivalents.map(
+          if (alternative.equivalents) {
+            alternative.equivalents = alternative.equivalents.map(
               (altQuantity) => {
                 if (altQuantity.quantity.type === "fixed" && altQuantity.quantity.value.type === "text") {
                   return altQuantity;
@@ -2815,15 +3007,15 @@ var _Recipe = class _Recipe {
           }
           const optimizedPrimary = applyBestUnit(
             {
-              quantity: alternative.itemQuantity.quantity,
-              unit: alternative.itemQuantity.unit
+              quantity: alternative.quantity,
+              unit: alternative.unit
             },
             unitSystem
           );
-          alternative.itemQuantity.quantity = optimizedPrimary.quantity;
-          alternative.itemQuantity.unit = optimizedPrimary.unit;
-          if (alternative.itemQuantity.equivalents) {
-            alternative.itemQuantity.equivalents = alternative.itemQuantity.equivalents.map(
+          alternative.quantity = optimizedPrimary.quantity;
+          alternative.unit = optimizedPrimary.unit;
+          if (alternative.equivalents) {
+            alternative.equivalents = alternative.equivalents.map(
               (eq) => applyBestUnit(eq, unitSystem)
             );
           }
@@ -2853,7 +3045,7 @@ var _Recipe = class _Recipe {
         factor
       );
     }
-    newRecipe._populate_ingredient_quantities();
+    newRecipe._populateIngredientQuantities();
     newRecipe.servings = Big4(originalServings).times(factor).toNumber();
     if (newRecipe.metadata.servings && this.metadata.servings) {
       if (floatRegex.test(String(this.metadata.servings).replace(",", ".").trim())) {
@@ -2918,27 +3110,36 @@ var _Recipe = class _Recipe {
       if (method === "remove") {
         return newPrimary;
       } else if (method === "replace") {
+        if (source === "converted") remainingEquivalents.push(oldPrimary);
         if (remainingEquivalents.length > 0) {
           newPrimary.equivalents = remainingEquivalents;
-          if (source === "converted") newPrimary.equivalents.push(oldPrimary);
         }
       } else {
         newPrimary.equivalents = [oldPrimary, ...remainingEquivalents];
       }
       return newPrimary;
     }
-    function convertItemQuantity(itemQuantity) {
-      const primaryUnit = resolveUnit(itemQuantity.unit?.name);
-      const equivalents = itemQuantity.equivalents ?? [];
+    function convertAlternativeQuantity(alternative) {
+      const primaryUnit = resolveUnit(alternative.unit?.name);
+      const equivalents = alternative.equivalents ?? [];
       const oldPrimary = {
-        quantity: itemQuantity.quantity,
-        unit: itemQuantity.unit
+        quantity: alternative.quantity,
+        unit: alternative.unit
       };
       if (primaryUnit.type !== "other" && isUnitCompatibleWithSystem(primaryUnit, system)) {
         if (method === "remove") {
-          return { ...itemQuantity, equivalents: void 0 };
+          return {
+            quantity: alternative.quantity,
+            unit: alternative.unit,
+            scalable: alternative.scalable
+          };
         }
-        return itemQuantity;
+        return {
+          quantity: alternative.quantity,
+          unit: alternative.unit,
+          scalable: alternative.scalable,
+          equivalents
+        };
       }
       const targetEquivIndex = equivalents.findIndex((eq) => {
         const eqUnit = resolveUnit(eq.unit?.name);
@@ -2953,7 +3154,7 @@ var _Recipe = class _Recipe {
           targetEquiv,
           oldPrimary,
           remainingEquivalents,
-          itemQuantity.scalable,
+          alternative.scalable,
           targetEquiv.unit?.integerProtected,
           "swapped"
         );
@@ -2964,8 +3165,8 @@ var _Recipe = class _Recipe {
           converted,
           oldPrimary,
           equivalents,
-          itemQuantity.scalable,
-          itemQuantity.unit?.integerProtected,
+          alternative.scalable,
+          alternative.unit?.integerProtected,
           "swapped"
         );
       }
@@ -2978,24 +3179,37 @@ var _Recipe = class _Recipe {
             convertedEquiv,
             oldPrimary,
             remainingEquivalents,
-            itemQuantity.scalable,
+            alternative.scalable,
             equiv.unit?.integerProtected,
             "converted"
           );
         }
       }
       if (method === "remove") {
-        return { ...itemQuantity, equivalents: void 0 };
+        return {
+          quantity: alternative.quantity,
+          unit: alternative.unit,
+          scalable: alternative.scalable
+        };
       } else {
-        return itemQuantity;
+        return {
+          quantity: alternative.quantity,
+          unit: alternative.unit,
+          scalable: alternative.scalable,
+          equivalents
+        };
       }
     }
     function convertAlternatives(alternatives) {
       for (const alternative of alternatives) {
-        if (alternative.itemQuantity) {
-          alternative.itemQuantity = convertItemQuantity(
-            alternative.itemQuantity
+        if (alternative.quantity) {
+          const converted = convertAlternativeQuantity(
+            alternative
           );
+          alternative.quantity = converted.quantity;
+          alternative.unit = converted.unit;
+          alternative.scalable = converted.scalable;
+          alternative.equivalents = converted.equivalents;
         }
       }
     }
@@ -3016,7 +3230,7 @@ var _Recipe = class _Recipe {
     for (const alternatives of newRecipe.choices.ingredientItems.values()) {
       convertAlternatives(alternatives);
     }
-    newRecipe._populate_ingredient_quantities();
+    newRecipe._populateIngredientQuantities();
     if (method !== "keep") _Recipe.unitSystems.set(newRecipe, system);
     return newRecipe;
   }
@@ -3069,9 +3283,9 @@ var Recipe = _Recipe;
 var ShoppingList = class {
   /**
    * Creates a new ShoppingList instance
-   * @param category_config_str - The category configuration to parse.
+   * @param categoryConfigStr - The category configuration to parse.
    */
-  constructor(category_config_str) {
+  constructor(categoryConfigStr) {
     // TODO: backport type change
     /**
      * The ingredients in the shopping list.
@@ -3084,16 +3298,16 @@ var ShoppingList = class {
     /**
      * The category configuration for the shopping list.
      */
-    __publicField(this, "category_config");
+    __publicField(this, "categoryConfig");
     /**
      * The categorized ingredients in the shopping list.
      */
     __publicField(this, "categories");
-    if (category_config_str) {
-      this.set_category_config(category_config_str);
+    if (categoryConfigStr) {
+      this.setCategoryConfig(categoryConfigStr);
     }
   }
-  calculate_ingredients() {
+  calculateIngredients() {
     this.ingredients = [];
     const addIngredientQuantity = (name, quantityTotal) => {
       const quantityTotalExtended = extendAllUnits(quantityTotal);
@@ -3180,7 +3394,7 @@ var ShoppingList = class {
    * @param options - Options for adding the recipe.
    * @throws Error if the recipe has alternatives without corresponding choices.
    */
-  add_recipe(recipe, options = {}) {
+  addRecipe(recipe, options = {}) {
     const errorMessage = this.getUnresolvedAlternativesError(
       recipe,
       options.choices
@@ -3209,7 +3423,7 @@ var ShoppingList = class {
         });
       }
     }
-    this.calculate_ingredients();
+    this.calculateIngredients();
     this.categorize();
   }
   /**
@@ -3249,15 +3463,15 @@ var ShoppingList = class {
   }
   /**
    * Removes a recipe from the shopping list, then automatically
-   * recalculates the quantities and recategorize the ingredients.s
+   * recalculates the quantities and recategorize the ingredients.
    * @param index - The index of the recipe to remove.
    */
-  remove_recipe(index) {
+  removeRecipe(index) {
     if (index < 0 || index >= this.recipes.length) {
       throw new Error("Index out of bounds");
     }
     this.recipes.splice(index, 1);
-    this.calculate_ingredients();
+    this.calculateIngredients();
     this.categorize();
   }
   /**
@@ -3265,10 +3479,10 @@ var ShoppingList = class {
    * and automatically categorize current ingredients from the list.
    * @param config - The category configuration to parse.
    */
-  set_category_config(config) {
+  setCategoryConfig(config) {
     if (typeof config === "string")
-      this.category_config = new CategoryConfig(config);
-    else if (config instanceof CategoryConfig) this.category_config = config;
+      this.categoryConfig = new CategoryConfig(config);
+    else if (config instanceof CategoryConfig) this.categoryConfig = config;
     else throw new Error("Invalid category configuration");
     this.categorize();
   }
@@ -3277,17 +3491,17 @@ var ShoppingList = class {
    * Will use the category config if any, otherwise all ingredients will be placed in the "other" category
    */
   categorize() {
-    if (!this.category_config) {
+    if (!this.categoryConfig) {
       this.categories = { other: this.ingredients };
       return;
     }
     const categories = { other: [] };
-    for (const category of this.category_config.categories) {
+    for (const category of this.categoryConfig.categories) {
       categories[category.name] = [];
     }
     for (const ingredient of this.ingredients) {
       let found = false;
-      for (const category of this.category_config.categories) {
+      for (const category of this.categoryConfig.categories) {
         for (const categoryIngredient of category.ingredients) {
           if (categoryIngredient.aliases.includes(ingredient.name)) {
             categories[category.name].push(ingredient);
@@ -3351,7 +3565,6 @@ var ShoppingCart = class {
   setProductCatalog(catalog) {
     this.productCatalog = catalog;
   }
-  // TODO: harmonize recipe name to use underscores
   /**
    * Sets the shopping list to build the cart from.
    * To use if a shopping list was not provided at the creation of the instance