@tmlmt/cooklang-parser 3.0.0-alpha.7 → 3.0.0-alpha.9

package/dist/index.cjs

@@ -39,7 +39,8 @@ __export(index_exports, {
   Recipe: () => Recipe,
   Section: () => Section,
   ShoppingCart: () => ShoppingCart,
-  ShoppingList: () => ShoppingList
+  ShoppingList: () => ShoppingList,
+  isAlternativeSelected: () => isAlternativeSelected
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -654,13 +655,13 @@ var InvalidQuantityFormat = class extends Error {
 
 // src/utils/type_guards.ts
 function isGroup(x) {
-  return x && "type" in x;
+  return "and" in x || "or" in x;
 }
 function isOrGroup(x) {
-  return isGroup(x) && x.type === "or";
+  return isGroup(x) && "or" in x;
 }
 function isAndGroup(x) {
-  return isGroup(x) && x.type === "and";
+  return isGroup(x) && "and" in x;
 }
 function isQuantity(x) {
   return x && typeof x === "object" && "quantity" in x;
@@ -679,8 +680,10 @@ function isValueIntegerLike(q) {
 
 // src/quantities/mutations.ts
 function extendAllUnits(q) {
-  if (isGroup(q)) {
-    return { ...q, entries: q.entries.map(extendAllUnits) };
+  if (isAndGroup(q)) {
+    return { and: q.and.map(extendAllUnits) };
+  } else if (isOrGroup(q)) {
+    return { or: q.or.map(extendAllUnits) };
   } else {
     const newQ = {
       quantity: q.quantity
@@ -692,13 +695,23 @@ function extendAllUnits(q) {
   }
 }
 function normalizeAllUnits(q) {
-  if (isGroup(q)) {
-    return { ...q, entries: q.entries.map(normalizeAllUnits) };
+  if (isAndGroup(q)) {
+    return { and: q.and.map(normalizeAllUnits) };
+  } else if (isOrGroup(q)) {
+    return { or: q.or.map(normalizeAllUnits) };
   } else {
     const newQ = {
       quantity: q.quantity,
       unit: resolveUnit(q.unit)
     };
+    if (q.equivalents && q.equivalents.length > 0) {
+      const equivalentsNormalized = q.equivalents.map(
+        (eq) => normalizeAllUnits(eq)
+      );
+      return {
+        or: [newQ, ...equivalentsNormalized]
+      };
+    }
     return newQ;
   }
 }
@@ -783,23 +796,23 @@ function addQuantities(q1, q2) {
 function toPlainUnit(quantity) {
   if (isQuantity(quantity))
     return quantity.unit ? { ...quantity, unit: quantity.unit.name } : quantity;
-  else {
+  else if (isOrGroup(quantity)) {
     return {
-      ...quantity,
-      entries: quantity.entries.map(toPlainUnit)
+      or: quantity.or.map(toPlainUnit)
+    };
+  } else {
+    return {
+      and: quantity.and.map(toPlainUnit)
     };
   }
 }
 function toExtendedUnit(q) {
   if (isQuantity(q)) {
     return q.unit ? { ...q, unit: { name: q.unit } } : q;
+  } else if (isOrGroup(q)) {
+    return { or: q.or.map(toExtendedUnit) };
   } else {
-    return {
-      ...q,
-      entries: q.entries.map(
-        (entry) => isQuantity(entry) ? toExtendedUnit(entry) : toExtendedUnit(entry)
-      )
-    };
+    return { and: q.and.map(toExtendedUnit) };
   }
 }
 function deNormalizeQuantity(q) {
@@ -813,26 +826,24 @@ function deNormalizeQuantity(q) {
 }
 var flattenPlainUnitGroup = (summed) => {
   if (isOrGroup(summed)) {
-    const entries = summed.entries;
+    const entries = summed.or;
     const andGroupEntry = entries.find(
-      (e2) => isGroup(e2) && e2.type === "and"
+      (e2) => isAndGroup(e2)
     );
     if (andGroupEntry) {
       const andEntries = [];
-      for (const entry of andGroupEntry.entries) {
-        if (isQuantity(entry)) {
-          andEntries.push({
-            quantity: entry.quantity,
-            unit: entry.unit
-          });
-        }
+      const addGroupEntryContent = andGroupEntry.and;
+      for (const entry of addGroupEntryContent) {
+        andEntries.push({
+          quantity: entry.quantity,
+          ...entry.unit && { unit: entry.unit }
+        });
       }
       const equivalentsList = entries.filter((e2) => isQuantity(e2)).map((e2) => ({ quantity: e2.quantity, unit: e2.unit }));
       if (equivalentsList.length > 0) {
         return [
           {
-            type: "and",
-            entries: andEntries,
+            and: andEntries,
             equivalents: equivalentsList
           }
         ];
@@ -856,25 +867,21 @@ var flattenPlainUnitGroup = (summed) => {
       const first = entries[0];
       return [{ quantity: first.quantity, unit: first.unit }];
     }
-  } else if (isGroup(summed)) {
+  } else if (isAndGroup(summed)) {
     const andEntries = [];
     const equivalentsList = [];
-    for (const entry of summed.entries) {
+    for (const entry of summed.and) {
       if (isOrGroup(entry)) {
-        const orEntries = entry.entries.filter(
-          (e2) => isQuantity(e2)
-        );
-        if (orEntries.length > 0) {
-          andEntries.push({
-            quantity: orEntries[0].quantity,
-            unit: orEntries[0].unit
-          });
-          equivalentsList.push(...orEntries.slice(1));
-        }
+        const orEntries = entry.or;
+        andEntries.push({
+          quantity: orEntries[0].quantity,
+          ...orEntries[0].unit && { unit: orEntries[0].unit }
+        });
+        equivalentsList.push(...orEntries.slice(1));
       } else if (isQuantity(entry)) {
         andEntries.push({
           quantity: entry.quantity,
-          unit: entry.unit
+          ...entry.unit && { unit: entry.unit }
         });
       }
     }
@@ -882,13 +889,14 @@ var flattenPlainUnitGroup = (summed) => {
       return andEntries;
     }
     const result = {
-      type: "and",
-      entries: andEntries,
+      and: andEntries,
       equivalents: equivalentsList
     };
     return [result];
   } else {
-    return [{ quantity: summed.quantity, unit: summed.unit }];
+    return [
+      { quantity: summed.quantity, ...summed.unit && { unit: summed.unit } }
+    ];
   }
 };
 
@@ -1371,11 +1379,11 @@ var deepClone = (v) => typeof structuredClone === "function" ? structuredClone(v
 // src/quantities/alternatives.ts
 function getEquivalentUnitsLists(...quantities) {
   const quantitiesCopy = deepClone(quantities);
-  const OrGroups = quantitiesCopy.filter(isOrGroup).filter((q) => q.entries.length > 1);
+  const OrGroups = quantitiesCopy.filter(isOrGroup).filter((q) => q.or.length > 1);
   const unitLists = [];
   const normalizeOrGroup = (og) => ({
     ...og,
-    entries: og.entries.map((q) => ({
+    or: og.or.map((q) => ({
       ...q,
       unit: resolveUnit(q.unit?.name, q.unit?.integerProtected)
     }))
@@ -1397,7 +1405,7 @@ function getEquivalentUnitsLists(...quantities) {
         ...v,
         unit: resolveUnit(v.unit?.name, v.unit?.integerProtected)
       };
-      const commonQuantity = og.entries.find(
+      const commonQuantity = og.or.find(
         (q) => isQuantity(q) && areUnitsCompatible(q.unit, normalizedV.unit)
       );
       if (commonQuantity) {
@@ -1406,7 +1414,7 @@ function getEquivalentUnitsLists(...quantities) {
       }
       return acc;
     }, []);
-    for (const newQ of og.entries) {
+    for (const newQ of og.or) {
       if (commonUnitList.some((q) => areUnitsCompatible(q.unit, newQ.unit))) {
         continue;
       } else {
@@ -1417,10 +1425,10 @@ function getEquivalentUnitsLists(...quantities) {
   }
   for (const orGroup of OrGroups) {
     const orGroupModified = normalizeOrGroup(orGroup);
-    const units2 = orGroupModified.entries.map((q) => q.unit);
+    const units2 = orGroupModified.or.map((q) => q.unit);
     const linkIndex = findLinkIndexForUnits(unitLists, units2);
     if (linkIndex === -1) {
-      unitLists.push(orGroupModified.entries);
+      unitLists.push(orGroupModified.or);
     } else {
       mergeOrGroupIntoList(unitLists, linkIndex, orGroupModified);
     }
@@ -1516,7 +1524,7 @@ function reduceOrsToFirstEquivalent(unitList, quantities) {
   return quantities.map((q) => {
     if (isQuantity(q)) return reduceToQuantity(q);
     const qListModified = sortUnitList(
-      q.entries.map((qq) => ({
+      q.or.map((qq) => ({
         ...qq,
         unit: resolveUnit(qq.unit?.name, qq.unit?.integerProtected)
       }))
@@ -1562,10 +1570,10 @@ function addQuantitiesOrGroups(...quantities) {
   if (sum.length === 1) {
     return { sum: sum[0], unitsLists };
   }
-  return { sum: { type: "and", entries: sum }, unitsLists };
+  return { sum: { and: sum }, unitsLists };
 }
 function regroupQuantitiesAndExpandEquivalents(sum, unitsLists) {
-  const sumQuantities = isGroup(sum) ? sum.entries : [sum];
+  const sumQuantities = isAndGroup(sum) ? sum.and : [sum];
   const result = [];
   const processedQuantities = /* @__PURE__ */ new Set();
   for (const list of unitsLists) {
@@ -1608,12 +1616,10 @@ function regroupQuantitiesAndExpandEquivalents(sum, unitsLists) {
     });
     if (main.length + equivalents.length > 1) {
       const resultMain = main.length > 1 ? {
-        type: "and",
-        entries: main.map(deNormalizeQuantity)
+        and: main.map(deNormalizeQuantity)
       } : deNormalizeQuantity(main[0]);
       result.push({
-        type: "or",
-        entries: [resultMain, ...equivalents]
+        or: [resultMain, ...equivalents]
       });
     } else {
       result.push(deNormalizeQuantity(main[0]));
@@ -1631,7 +1637,7 @@ function addEquivalentsAndSimplify(...quantities) {
   if (regrouped.length === 1) {
     return toPlainUnit(regrouped[0]);
   } else {
-    return { type: "and", entries: regrouped.map(toPlainUnit) };
+    return { and: regrouped.map(toPlainUnit) };
   }
 }
 
@@ -1648,8 +1654,7 @@ var _Recipe = class _Recipe {
      */
     __publicField(this, "metadata", {});
     /**
-     * The default or manual choice of alternative ingredients.
-     * Contains the full context including alternatives list and active selection index.
+     * The possible choices of alternative ingredients for this recipe.
      */
     __publicField(this, "choices", {
       ingredientItems: /* @__PURE__ */ new Map(),
@@ -1712,7 +1717,7 @@ var _Recipe = class _Recipe {
     if (!regexMatchGroups || !regexMatchGroups.arbitraryQuantity) return;
     const quantityMatch = regexMatchGroups.arbitraryQuantity?.trim().match(quantityAlternativeRegex);
     if (quantityMatch?.groups) {
-      const value = quantityMatch.groups.quantity ? parseQuantityInput(quantityMatch.groups.quantity) : void 0;
+      const value = parseQuantityInput(quantityMatch.groups.quantity);
       const unit = quantityMatch.groups.unit;
       const name = regexMatchGroups.arbitraryName || void 0;
       if (!value || value.type === "fixed" && value.value.type === "text") {
@@ -2015,286 +2020,229 @@ var _Recipe = class _Recipe {
    * @internal
    */
   _populate_ingredient_quantities() {
-    this.ingredients = this.ingredients.map((ing) => {
-      if (ing.quantities) {
-        delete ing.quantities;
+    for (const ing of this.ingredients) {
+      delete ing.quantities;
+      delete ing.usedAsPrimary;
+    }
+    const ingredientsWithQuantities = this.getIngredientQuantities();
+    const matchedIndices = /* @__PURE__ */ new Set();
+    for (const computed of ingredientsWithQuantities) {
+      const idx = this.ingredients.findIndex(
+        (ing2, i2) => ing2.name === computed.name && !matchedIndices.has(i2)
+      );
+      matchedIndices.add(idx);
+      const ing = this.ingredients[idx];
+      if (computed.quantities) {
+        ing.quantities = computed.quantities;
       }
-      if (ing.usedAsPrimary) {
-        delete ing.usedAsPrimary;
+      if (computed.usedAsPrimary) {
+        ing.usedAsPrimary = true;
       }
-      return ing;
-    });
-    const seenGroups = /* @__PURE__ */ new Set();
+    }
+  }
+  /**
+   * Gets ingredients with their quantities populated, optionally filtered by section/step
+   * and respecting user choices for alternatives.
+   *
+   * When no options are provided, returns all recipe ingredients with quantities
+   * calculated using primary alternatives (same as after parsing).
+   *
+   * @param options - Options for filtering and choice selection:
+   *   - `section`: Filter to a specific section (Section object or 0-based index)
+   *   - `step`: Filter to a specific step (Step object or 0-based index)
+   *   - `choices`: Choices for alternative ingredients (defaults to primary)
+   * @returns Array of Ingredient objects with quantities populated
+   *
+   * @example
+   * ```typescript
+   * // Get all ingredients with primary alternatives
+   * const ingredients = recipe.getIngredientQuantities();
+   *
+   * // Get ingredients for a specific section
+   * const sectionIngredients = recipe.getIngredientQuantities({ section: 0 });
+   *
+   * // Get ingredients with specific choices applied
+   * const withChoices = recipe.getIngredientQuantities({
+   *   choices: { ingredientItems: new Map([['ingredient-item-2', 1]]) }
+   * });
+   * ```
+   */
+  getIngredientQuantities(options) {
+    const { section, step, choices } = options || {};
+    const sectionsToProcess = section !== void 0 ? (() => {
+      const idx = typeof section === "number" ? section : this.sections.indexOf(section);
+      return idx >= 0 && idx < this.sections.length ? [this.sections[idx]] : [];
+    })() : this.sections;
     const ingredientGroups = /* @__PURE__ */ new Map();
-    for (const section of this.sections) {
-      for (const step of section.content.filter(
+    const selectedIndices = /* @__PURE__ */ new Set();
+    const referencedIndices = /* @__PURE__ */ new Set();
+    for (const currentSection of sectionsToProcess) {
+      const allSteps = currentSection.content.filter(
         (item) => item.type === "step"
-      )) {
-        for (const item of step.items.filter(
+      );
+      const stepsToProcess = step === void 0 ? allSteps : typeof step === "number" ? step >= 0 && step < allSteps.length ? [allSteps[step]] : [] : allSteps.includes(step) ? [step] : [];
+      for (const currentStep of stepsToProcess) {
+        for (const item of currentStep.items.filter(
           (item2) => item2.type === "ingredient"
         )) {
-          const isGroupedItem = "group" in item && item.group !== void 0;
-          const isFirstInGroup = isGroupedItem && !seenGroups.has(item.group);
-          if (isGroupedItem) {
-            seenGroups.add(item.group);
+          const isGrouped = "group" in item && item.group !== void 0;
+          const groupAlternatives = isGrouped ? this.choices.ingredientGroups.get(item.group) : void 0;
+          let selectedAltIndex = 0;
+          let isSelected = false;
+          let hasExplicitChoice = false;
+          if (isGrouped) {
+            const groupChoice = choices?.ingredientGroups?.get(item.group);
+            hasExplicitChoice = groupChoice !== void 0;
+            const targetIndex = groupChoice ?? 0;
+            isSelected = groupAlternatives?.[targetIndex]?.itemId === item.id;
+          } else {
+            const itemChoice = choices?.ingredientItems?.get(item.id);
+            hasExplicitChoice = itemChoice !== void 0;
+            selectedAltIndex = itemChoice ?? 0;
+            isSelected = true;
           }
-          const isPrimary = !isGroupedItem || isFirstInGroup;
-          const alternative = item.alternatives[0];
-          if (isPrimary) {
-            const primaryIngredient = this.ingredients[alternative.index];
-            if (primaryIngredient) {
-              primaryIngredient.usedAsPrimary = true;
-            }
+          const alternative = item.alternatives[selectedAltIndex];
+          if (!alternative || !isSelected) continue;
+          selectedIndices.add(alternative.index);
+          const allAlts = isGrouped ? groupAlternatives : item.alternatives;
+          for (const alt of allAlts) {
+            referencedIndices.add(alt.index);
           }
-          if (!isPrimary || !alternative.itemQuantity) continue;
-          const allQuantities = [
-            {
-              quantity: alternative.itemQuantity.quantity,
+          if (!alternative.itemQuantity) continue;
+          const baseQty = {
+            quantity: alternative.itemQuantity.quantity,
+            ...alternative.itemQuantity.unit && {
               unit: alternative.itemQuantity.unit
             }
-          ];
-          if (alternative.itemQuantity.equivalents) {
-            allQuantities.push(...alternative.itemQuantity.equivalents);
-          }
-          const quantityEntry = allQuantities.length === 1 ? allQuantities[0] : { type: "or", entries: allQuantities };
-          const hasInlineAlternatives = item.alternatives.length > 1;
-          const hasGroupedAlternatives = isGroupedItem && this.choices.ingredientGroups.has(item.group);
+          };
+          const quantityEntry = alternative.itemQuantity.equivalents?.length ? { or: [baseQty, ...alternative.itemQuantity.equivalents] } : baseQty;
           let alternativeRefs;
-          if (hasInlineAlternatives) {
-            alternativeRefs = [];
-            for (let j = 1; j < item.alternatives.length; j++) {
-              const otherAlt = item.alternatives[j];
-              const newRef = {
-                index: otherAlt.index
-              };
+          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) {
                 const altQty = {
-                  quantity: otherAlt.itemQuantity.quantity
+                  quantity: otherAlt.itemQuantity.quantity,
+                  ...otherAlt.itemQuantity.unit && {
+                    unit: otherAlt.itemQuantity.unit.name
+                  },
+                  ...otherAlt.itemQuantity.equivalents && {
+                    equivalents: otherAlt.itemQuantity.equivalents.map(
+                      (eq) => toPlainUnit(eq)
+                    )
+                  }
                 };
-                if (otherAlt.itemQuantity.unit) {
-                  altQty.unit = otherAlt.itemQuantity.unit.name;
-                }
-                if (otherAlt.itemQuantity.equivalents) {
-                  altQty.equivalents = otherAlt.itemQuantity.equivalents.map(
-                    (eq) => toPlainUnit(eq)
-                  );
-                }
-                newRef.quantities = [altQty];
+                ref.quantities = [altQty];
               }
-              alternativeRefs.push(newRef);
-            }
-          } else if (hasGroupedAlternatives) {
-            const groupAlternatives = this.choices.ingredientGroups.get(
-              item.group
+              return ref;
+            });
+          }
+          const altIndices = getAlternativeSignature(alternativeRefs) ?? "";
+          let signature;
+          if (isGrouped) {
+            const resolvedUnit = resolveUnit(
+              alternative.itemQuantity.unit?.name
             );
-            alternativeRefs = [];
-            for (let j = 1; j < groupAlternatives.length; j++) {
-              const otherAlt = groupAlternatives[j];
-              if (otherAlt.itemQuantity) {
-                const altQty = {
-                  quantity: otherAlt.itemQuantity.quantity
-                };
-                if (otherAlt.itemQuantity.unit) {
-                  altQty.unit = otherAlt.itemQuantity.unit.name;
-                }
-                if (otherAlt.itemQuantity.equivalents) {
-                  altQty.equivalents = otherAlt.itemQuantity.equivalents.map(
-                    (eq) => toPlainUnit(eq)
-                  );
-                }
-                alternativeRefs.push({
-                  index: otherAlt.index,
-                  quantities: [altQty]
-                });
-              }
-            }
-            if (alternativeRefs.length === 0) {
-              alternativeRefs = void 0;
-            }
+            signature = `group:${item.group}|${altIndices}|${resolvedUnit.type}`;
+          } else if (altIndices) {
+            const resolvedUnit = resolveUnit(
+              alternative.itemQuantity.unit?.name
+            );
+            signature = `${altIndices}|${resolvedUnit.type}}`;
+          } else {
+            signature = null;
           }
           if (!ingredientGroups.has(alternative.index)) {
             ingredientGroups.set(alternative.index, /* @__PURE__ */ new Map());
           }
-          const groupsForIngredient = ingredientGroups.get(alternative.index);
-          const baseSignature = getAlternativeSignature(alternativeRefs);
-          const signature = isGroupedItem ? `group:${item.group}|${baseSignature ?? ""}` : baseSignature;
-          if (!groupsForIngredient.has(signature)) {
-            groupsForIngredient.set(signature, {
-              alternativeQuantities: /* @__PURE__ */ new Map(),
-              quantities: []
+          const groupsForIng = ingredientGroups.get(alternative.index);
+          if (!groupsForIng.has(signature)) {
+            groupsForIng.set(signature, {
+              quantities: [],
+              alternativeQuantities: /* @__PURE__ */ new Map()
             });
           }
-          const group = groupsForIngredient.get(signature);
+          const group = groupsForIng.get(signature);
           group.quantities.push(quantityEntry);
-          if (alternativeRefs) {
-            for (const ref of alternativeRefs) {
-              if (!group.alternativeQuantities.has(ref.index)) {
-                group.alternativeQuantities.set(ref.index, []);
-              }
-              if (ref.quantities && ref.quantities.length > 0) {
-                for (const altQty of ref.quantities) {
-                  if (altQty.equivalents && altQty.equivalents.length > 0) {
-                    const entries = [
-                      toExtendedUnit({
-                        quantity: altQty.quantity,
-                        unit: altQty.unit
-                      }),
-                      ...altQty.equivalents.map((eq) => toExtendedUnit(eq))
-                    ];
-                    group.alternativeQuantities.get(ref.index).push({ type: "or", entries });
-                  } else {
-                    group.alternativeQuantities.get(ref.index).push(
-                      toExtendedUnit({
-                        quantity: altQty.quantity,
-                        unit: altQty.unit
-                      })
-                    );
-                  }
-                }
-              }
+          for (const ref of alternativeRefs ?? []) {
+            if (!group.alternativeQuantities.has(ref.index)) {
+              group.alternativeQuantities.set(ref.index, []);
             }
-          }
-        }
-      }
-    }
-    for (const [index, groupsForIngredient] of ingredientGroups) {
-      const ingredient = this.ingredients[index];
-      const quantityGroups = [];
-      for (const [, group] of groupsForIngredient) {
-        const summedGroupQuantity = addEquivalentsAndSimplify(
-          ...group.quantities
-        );
-        const groupQuantities = flattenPlainUnitGroup(summedGroupQuantity);
-        let alternatives;
-        if (group.alternativeQuantities.size > 0) {
-          alternatives = [];
-          for (const [altIndex, altQuantities] of group.alternativeQuantities) {
-            const ref = { index: altIndex };
-            if (altQuantities.length > 0) {
-              const summedAltQuantity = addEquivalentsAndSimplify(
-                ...altQuantities
-              );
-              const flattenedAlt = flattenPlainUnitGroup(summedAltQuantity);
-              ref.quantities = flattenedAlt.flatMap((item) => {
-                if ("quantity" in item) {
-                  return [item];
-                } else {
-                  return item.entries;
-                }
+            for (const altQty of ref.quantities ?? []) {
+              const extended = toExtendedUnit({
+                quantity: altQty.quantity,
+                unit: altQty.unit
               });
-            }
-            alternatives.push(ref);
-          }
-        }
-        for (const gq of groupQuantities) {
-          if ("type" in gq && gq.type === "and") {
-            const andGroup = {
-              type: "and",
-              entries: gq.entries
-            };
-            if (gq.equivalents && gq.equivalents.length > 0) {
-              andGroup.equivalents = gq.equivalents;
-            }
-            if (alternatives && alternatives.length > 0) {
-              andGroup.alternatives = alternatives;
-            }
-            quantityGroups.push(andGroup);
-          } else {
-            const quantityGroup = gq;
-            if (alternatives && alternatives.length > 0) {
-              quantityGroup.alternatives = alternatives;
-            }
-            quantityGroups.push(quantityGroup);
-          }
-        }
-      }
-      if (quantityGroups.length > 0) {
-        ingredient.quantities = quantityGroups;
-      }
-    }
-  }
-  /**
-   * Calculates ingredient quantities based on the provided choices.
-   * Returns a list of computed ingredients with their total quantities.
-   *
-   * @param choices - The recipe choices to apply when computing quantities.
-   *   If not provided, uses the default choices (first alternative for each item).
-   * @returns An array of ComputedIngredient with quantityTotal calculated based on choices.
-   */
-  calc_ingredient_quantities(choices) {
-    const effectiveChoices = choices || {
-      ingredientItems: new Map(
-        Array.from(this.choices.ingredientItems.keys()).map((k) => [k, 0])
-      ),
-      ingredientGroups: new Map(
-        Array.from(this.choices.ingredientGroups.keys()).map((k) => [k, 0])
-      )
-    };
-    const ingredientQuantities = /* @__PURE__ */ new Map();
-    const selectedIngredientIndices = /* @__PURE__ */ new Set();
-    for (const section of this.sections) {
-      for (const step of section.content.filter(
-        (item) => item.type === "step"
-      )) {
-        for (const item of step.items.filter(
-          (item2) => item2.type === "ingredient"
-        )) {
-          for (let i2 = 0; i2 < item.alternatives.length; i2++) {
-            const alternative = item.alternatives[i2];
-            const isAlternativeChoiceItem = effectiveChoices.ingredientItems?.get(item.id) === i2;
-            const alternativeChoiceGroupIdx = item.group ? effectiveChoices.ingredientGroups?.get(item.group) : void 0;
-            const alternativeChoiceGroup = item.group ? this.choices.ingredientGroups.get(item.group) : void 0;
-            const isAlternativeChoiceGroup = alternativeChoiceGroup && alternativeChoiceGroupIdx !== void 0 ? alternativeChoiceGroup[alternativeChoiceGroupIdx]?.itemId === item.id : false;
-            const isSelected = !("group" in item) && (item.alternatives.length === 1 || isAlternativeChoiceItem) || isAlternativeChoiceGroup;
-            if (isSelected) {
-              selectedIngredientIndices.add(alternative.index);
-              if (alternative.itemQuantity) {
-                const allQuantities = [
-                  {
-                    quantity: alternative.itemQuantity.quantity,
-                    unit: alternative.itemQuantity.unit
-                  }
+              if (altQty.equivalents?.length) {
+                const eqEntries = [
+                  extended,
+                  ...altQty.equivalents.map((eq) => toExtendedUnit(eq))
                 ];
-                if (alternative.itemQuantity.equivalents) {
-                  allQuantities.push(...alternative.itemQuantity.equivalents);
-                }
-                const equivalents = allQuantities.length === 1 ? allQuantities[0] : {
-                  type: "or",
-                  entries: allQuantities
-                };
-                ingredientQuantities.set(alternative.index, [
-                  ...ingredientQuantities.get(alternative.index) || [],
-                  equivalents
-                ]);
+                group.alternativeQuantities.get(ref.index).push({ or: eqEntries });
+              } else {
+                group.alternativeQuantities.get(ref.index).push(extended);
               }
             }
           }
         }
       }
     }
-    const computedIngredients = [];
+    const result = [];
     for (let index = 0; index < this.ingredients.length; index++) {
-      if (!selectedIngredientIndices.has(index)) continue;
-      const ing = this.ingredients[index];
-      const computed = {
-        name: ing.name
+      if (!referencedIndices.has(index)) continue;
+      const orig = this.ingredients[index];
+      const ing = {
+        name: orig.name,
+        ...orig.preparation && { preparation: orig.preparation },
+        ...orig.flags && { flags: orig.flags },
+        ...orig.extras && { extras: orig.extras }
       };
-      if (ing.preparation) {
-        computed.preparation = ing.preparation;
-      }
-      if (ing.flags) {
-        computed.flags = ing.flags;
-      }
-      if (ing.extras) {
-        computed.extras = ing.extras;
-      }
-      const quantities = ingredientQuantities.get(index);
-      if (quantities && quantities.length > 0) {
-        computed.quantityTotal = addEquivalentsAndSimplify(...quantities);
+      if (selectedIndices.has(index)) {
+        ing.usedAsPrimary = true;
+        const groupsForIng = ingredientGroups.get(index);
+        if (groupsForIng) {
+          const quantityGroups = [];
+          for (const [, group] of groupsForIng) {
+            const summed = addEquivalentsAndSimplify(...group.quantities);
+            const flattened = flattenPlainUnitGroup(summed);
+            const alternatives = group.alternativeQuantities.size > 0 ? [...group.alternativeQuantities].map(([altIdx, altQtys]) => ({
+              index: altIdx,
+              ...altQtys.length > 0 && {
+                quantities: flattenPlainUnitGroup(
+                  addEquivalentsAndSimplify(...altQtys)
+                ).flatMap(
+                  /* v8 ignore next -- item.and branch requires complex nested AND-with-equivalents structure */
+                  (item) => "quantity" in item ? [item] : item.and
+                )
+              }
+            })) : void 0;
+            for (const gq of flattened) {
+              if ("and" in gq) {
+                quantityGroups.push({
+                  and: gq.and,
+                  ...gq.equivalents?.length && {
+                    equivalents: gq.equivalents
+                  },
+                  ...alternatives?.length && { alternatives }
+                });
+              } else {
+                quantityGroups.push({
+                  ...gq,
+                  ...alternatives?.length && { alternatives }
+                });
+              }
+            }
+          }
+          if (quantityGroups.length > 0) {
+            ing.quantities = quantityGroups;
+          }
+        }
       }
-      computedIngredients.push(computed);
+      result.push(ing);
     }
-    return computedIngredients;
+    return result;
   }
   /**
    * Parses a recipe from a string.
@@ -2343,10 +2291,6 @@ var _Recipe = class _Recipe {
       }
       if (blankLineBefore && line.startsWith(">")) {
         flushPendingItems(section, items);
-        flushPendingNote(
-          section,
-          noteText ? this._parseNoteText(noteText) : []
-        );
         noteText = line.substring(1).trim();
         inNote = true;
         blankLineBefore = false;
@@ -2361,8 +2305,6 @@ var _Recipe = class _Recipe {
         blankLineBefore = false;
         continue;
       }
-      flushPendingNote(section, noteText ? this._parseNoteText(noteText) : []);
-      noteText = "";
       let cursor = 0;
       for (const match of line.matchAll(tokensRegex)) {
         const idx = match.index;
@@ -2627,7 +2569,7 @@ var ShoppingList = class {
     this.ingredients = [];
     const addIngredientQuantity = (name, quantityTotal) => {
       const quantityTotalExtended = extendAllUnits(quantityTotal);
-      const newQuantities = isAndGroup(quantityTotalExtended) ? quantityTotalExtended.entries : [quantityTotalExtended];
+      const newQuantities = isAndGroup(quantityTotalExtended) ? quantityTotalExtended.and : [quantityTotalExtended];
       const existing = this.ingredients.find((i2) => i2.name === name);
       if (existing) {
         if (!existing.quantityTotal) {
@@ -2638,7 +2580,7 @@ var ShoppingList = class {
           const existingQuantityTotalExtended = extendAllUnits(
             existing.quantityTotal
           );
-          const existingQuantities = isAndGroup(existingQuantityTotalExtended) ? existingQuantityTotalExtended.entries : [existingQuantityTotalExtended];
+          const existingQuantities = isAndGroup(existingQuantityTotalExtended) ? existingQuantityTotalExtended.and : [existingQuantityTotalExtended];
           existing.quantityTotal = addEquivalentsAndSimplify(
             ...existingQuantities,
             ...newQuantities
@@ -2660,15 +2602,43 @@ var ShoppingList = class {
       } else {
         scaledRecipe = addedRecipe.recipe.scaleTo(addedRecipe.servings);
       }
-      const computedIngredients = scaledRecipe.calc_ingredient_quantities(
-        addedRecipe.choices
-      );
-      for (const ingredient of computedIngredients) {
+      const ingredients = scaledRecipe.getIngredientQuantities({
+        choices: addedRecipe.choices
+      });
+      for (const ingredient of ingredients) {
         if (ingredient.flags && ingredient.flags.includes("hidden")) {
           continue;
         }
-        if (ingredient.quantityTotal) {
-          addIngredientQuantity(ingredient.name, ingredient.quantityTotal);
+        if (!ingredient.usedAsPrimary) {
+          continue;
+        }
+        if (ingredient.quantities && ingredient.quantities.length > 0) {
+          const allQuantities = [];
+          for (const qGroup of ingredient.quantities) {
+            if ("and" in qGroup) {
+              for (const qty of qGroup.and) {
+                allQuantities.push(qty);
+              }
+            } else {
+              const plainQty = {
+                quantity: qGroup.quantity
+              };
+              if (qGroup.unit) plainQty.unit = qGroup.unit;
+              if (qGroup.equivalents) plainQty.equivalents = qGroup.equivalents;
+              allQuantities.push(plainQty);
+            }
+          }
+          if (allQuantities.length === 1) {
+            addIngredientQuantity(ingredient.name, allQuantities[0]);
+          } else {
+            const extendedQuantities = allQuantities.map(
+              (q) => extendAllUnits(q)
+            );
+            const totalQuantity = addEquivalentsAndSimplify(
+              ...extendedQuantities
+            );
+            addIngredientQuantity(ingredient.name, totalQuantity);
+          }
         } else if (!this.ingredients.some((i2) => i2.name === ingredient.name)) {
           this.ingredients.push({ name: ingredient.name });
         }
@@ -2680,8 +2650,16 @@ var ShoppingList = class {
    * recalculates the quantities and recategorize the ingredients.
    * @param recipe - The recipe to add.
    * @param options - Options for adding the recipe.
+   * @throws Error if the recipe has alternatives without corresponding choices.
    */
   add_recipe(recipe, options = {}) {
+    const errorMessage = this.getUnresolvedAlternativesError(
+      recipe,
+      options.choices
+    );
+    if (errorMessage) {
+      throw new Error(errorMessage);
+    }
     if (!options.scaling) {
       this.recipes.push({
         recipe,
@@ -2706,6 +2684,41 @@ var ShoppingList = class {
     this.calculate_ingredients();
     this.categorize();
   }
+  /**
+   * Checks if a recipe has unresolved alternatives (alternatives without provided choices).
+   * @param recipe - The recipe to check.
+   * @param choices - The choices provided for the recipe.
+   * @returns An error message if there are unresolved alternatives, undefined otherwise.
+   */
+  getUnresolvedAlternativesError(recipe, choices) {
+    const missingItems = [];
+    const missingGroups = [];
+    for (const itemId of recipe.choices.ingredientItems.keys()) {
+      if (!choices?.ingredientItems?.has(itemId)) {
+        missingItems.push(itemId);
+      }
+    }
+    for (const groupId of recipe.choices.ingredientGroups.keys()) {
+      if (!choices?.ingredientGroups?.has(groupId)) {
+        missingGroups.push(groupId);
+      }
+    }
+    if (missingItems.length === 0 && missingGroups.length === 0) {
+      return void 0;
+    }
+    const parts = [];
+    if (missingItems.length > 0) {
+      parts.push(
+        `ingredientItems: [${missingItems.map((i2) => `'${i2}'`).join(", ")}]`
+      );
+    }
+    if (missingGroups.length > 0) {
+      parts.push(
+        `ingredientGroups: [${missingGroups.map((g) => `'${g}'`).join(", ")}]`
+      );
+    }
+    return `Recipe has unresolved alternatives. Missing choices for: ${parts.join(", ")}`;
+  }
   /**
    * Removes a recipe from the shopping list, then automatically
    * recalculates the quantities and recategorize the ingredients.s
@@ -2894,7 +2907,7 @@ var ShoppingCart = class {
     const normalizedQuantityTotal = normalizeAllUnits(ingredient.quantityTotal);
     function getOptimumMatchForQuantityParts(normalizedQuantities, normalizedOptions2, selection = []) {
       if (isAndGroup(normalizedQuantities)) {
-        for (const q of normalizedQuantities.entries) {
+        for (const q of normalizedQuantities.and) {
           const result = getOptimumMatchForQuantityParts(
             q,
             normalizedOptions2,
@@ -2903,7 +2916,7 @@ var ShoppingCart = class {
           selection.push(...result);
         }
       } else {
-        const alternativeUnitsOfQuantity = isOrGroup(normalizedQuantities) ? normalizedQuantities.entries : [normalizedQuantities];
+        const alternativeUnitsOfQuantity = isOrGroup(normalizedQuantities) ? normalizedQuantities.or : [normalizedQuantities];
         const solutions = [];
         const errors = /* @__PURE__ */ new Set();
         for (const alternative of alternativeUnitsOfQuantity) {
@@ -3023,6 +3036,21 @@ var ShoppingCart = class {
     return this.summary;
   }
 };
+
+// src/utils/render_helpers.ts
+function isAlternativeSelected(recipe, choices, item, alternativeIndex) {
+  if (item.group) {
+    const selectedIndex2 = choices?.ingredientGroups?.get(item.group);
+    const groupAlternatives = recipe.choices.ingredientGroups.get(item.group);
+    if (groupAlternatives && selectedIndex2 && selectedIndex2 < groupAlternatives.length) {
+      const selectedItemId = groupAlternatives[selectedIndex2]?.itemId;
+      return selectedItemId === item.id;
+    }
+    return false;
+  }
+  const selectedIndex = choices?.ingredientItems?.get(item.id);
+  return alternativeIndex === selectedIndex;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   CategoryConfig,
@@ -3032,9 +3060,12 @@ var ShoppingCart = class {
   Recipe,
   Section,
   ShoppingCart,
-  ShoppingList
+  ShoppingList,
+  isAlternativeSelected
 });
 /* v8 ignore else -- @preserve */
+// v8 ignore else -- @preserve
 /* v8 ignore else -- expliciting error type -- @preserve */
+// v8 ignore if -- @preserve
 /* v8 ignore if -- @preserve */
 //# sourceMappingURL=index.cjs.map