feat: scale cookware quantities

Author: tmlmt

docs/examples-scaling-recipes.md

@@ -30,6 +30,7 @@ const scaledRecipe = recipe.scaleBy(2)
 
 In the above example, will be multiplied by 2:
 - All the ingredients (including alternative units and alternative ingredients) with scalable numerical quantities
+- [Cookware quantities](/guide-extensions.html#cookware-quantities) (integer quantities are rounded up, with a minimum of 1)
 - The scaling metadata and `servings` value
 - [Arbitrary scalable quantities](/guide-extensions.html#arbitrary-scalable-quantities)
 
@@ -46,5 +47,6 @@ const scaledRecipe = recipe.scaleTo(4)
 
 In the above example, will be adjusted by a factor of 4/2: 
 - All the ingredients (including alternative units and alternative ingredients) with scalable numerical quantities have their quantities adjusted by a factor of 4/2 in this case
+- [Cookware quantities](/guide-extensions.html#cookware-quantities) (integer quantities are rounded up, with a minimum of 1)
 - The scaling metadata and `servings` value
 - [Arbitrary scalable quantities](/guide-extensions.html#arbitrary-scalable-quantities)

docs/guide-extensions.md

@@ -206,6 +206,11 @@ Example: .cook string `Mix @wheat flour{100%g} with additional @&wheat flour|flo
 
 - Cookware can also be quantified (without any unit, e.g. `#bowls{2}`)
 - Quantities will be added similarly as ingredients if cookware is referenced, e.g. `#&bowls{2}`
+- Cookware quantities are scaled by [`scaleBy`](/api/classes/Recipe#scaleBy) and [`scaleTo`](/api/classes/Recipe#scaleTo), with two special rules:
+  - **Integer quantities** are rounded up (ceiling) after scaling, with a minimum of `1`. For example, `#bowl{1}` scaled by `0.5` stays `1` (not `0.5`), and scaled by `1.5` becomes `2`.
+  - **Non-integer quantities** are scaled as-is without rounding. For example, `#sticks{2.5}` scaled by `1.5` becomes `3.75`.
+  - **Range quantities** (e.g. `#pans{1-2}`) follow the same rules — if both bounds are integers, each is individually rounded up after scaling.
+- Cookware without a quantity (e.g. `#oven`) is never affected by scaling.
 
 ## Arbitrary scalable quantities
 

src/classes/recipe.ts

@@ -21,6 +21,10 @@ import type {
   IngredientQuantityAndGroup,
   ArbitraryScalable,
   FixedNumericValue,
+  FixedValue,
+  Range,
+  DecimalValue,
+  FractionValue,
   StepItem,
   GetIngredientQuantitiesOptions,
   RawQuantityGroup,
@@ -56,7 +60,11 @@ import {
   parseMarkdownSegments,
 } from "../utils/parser_helpers";
 import { addEquivalentsAndSimplify } from "../quantities/alternatives";
-import { multiplyQuantityValue, getAverageValue } from "../quantities/numeric";
+import {
+  multiplyQuantityValue,
+  getAverageValue,
+  getNumericValue,
+} from "../quantities/numeric";
 import {
   toPlainUnit,
   toExtendedUnit,
@@ -1801,6 +1809,51 @@ export class Recipe {
       }
     }
 
+    function scaleCookwareQuantity(
+      quantity: FixedValue | Range,
+      factor: number | Big,
+    ): FixedValue | Range {
+      // Text quantities cannot be scaled; return as-is
+      if (quantity.type === "fixed" && quantity.value.type === "text") {
+        return quantity;
+      }
+
+      const isInteger = (q: FixedValue | Range): boolean => {
+        if (q.type === "fixed") {
+          return Number.isInteger(
+            getNumericValue(q.value as DecimalValue | FractionValue),
+          );
+        }
+        return (
+          Number.isInteger(getNumericValue(q.min)) &&
+          Number.isInteger(getNumericValue(q.max))
+        );
+      };
+
+      const scaled = multiplyQuantityValue(quantity, factor);
+
+      if (!isInteger(quantity)) return scaled;
+
+      if (scaled.type === "fixed") {
+        const n = getNumericValue(scaled.value as DecimalValue | FractionValue);
+        return {
+          type: "fixed",
+          value: { type: "decimal", decimal: Math.max(1, Math.ceil(n)) },
+        };
+      }
+      return {
+        type: "range",
+        min: {
+          type: "decimal",
+          decimal: Math.max(1, Math.ceil(getNumericValue(scaled.min))),
+        },
+        max: {
+          type: "decimal",
+          decimal: Math.max(1, Math.ceil(getNumericValue(scaled.max))),
+        },
+      };
+    }
+
     // Scale IngredientItems
     for (const section of newRecipe.sections) {
       for (const step of section.content.filter(
@@ -1814,6 +1867,28 @@ export class Recipe {
       }
     }
 
+    // Scale CookwareItem quantities in steps
+    for (const section of newRecipe.sections) {
+      for (const step of section.content.filter(
+        (item) => item.type === "step",
+      )) {
+        for (const item of step.items.filter(
+          (item) => item.type === "cookware",
+        )) {
+          if (item.quantity) {
+            item.quantity = scaleCookwareQuantity(item.quantity, factor);
+          }
+        }
+      }
+    }
+
+    // Scale Recipe.cookware[] quantities
+    for (const cookware of newRecipe.cookware) {
+      if (cookware.quantity) {
+        cookware.quantity = scaleCookwareQuantity(cookware.quantity, factor);
+      }
+    }
+
     // Scale Choices
     for (const subgroups of newRecipe.choices.ingredientGroups.values()) {
       for (const subgroup of subgroups) {

test/fixtures/recipes.ts

@@ -128,6 +128,12 @@ servings: 1
 ---
 Mix @milk{200%ml}|almond milk{100%ml}[vegan version]|soy milk{150%ml}[another vegan option]`;
 
+export const recipeCookwareScaling = `
+#bowl{1}
+#sticks{2.5}
+#oven
+`;
+
 export const recipeWithGroupedAlternatives = `
 ---
 servings: 1

test/recipe_scaling.test.ts

@@ -1,5 +1,6 @@
 import { describe, it, expect } from "vitest";
 import type {
+  CookwareItem,
   IngredientAlternative,
   IngredientItem,
   IngredientQuantityGroup,
@@ -13,6 +14,7 @@ import {
   recipeToScale,
   recipeToScaleSomeFixedQuantities,
   recipeWithInlineAlternatives,
+  recipeCookwareScaling,
 } from "./fixtures/recipes";
 import { recipeWithUnitServings } from "./fixtures/recipes";
 
@@ -1034,3 +1036,96 @@ Add @cream{1%cup|a pinch%ml}.
     });
   });
 });
+
+describe("scaleBy cookware quantities", () => {
+  const baseRecipe = new Recipe(recipeCookwareScaling);
+
+  it("should scale up cookware quantities, rounding up integers and applying minimum 1", () => {
+    const scaled = baseRecipe.scaleBy(1.5);
+    // bowl{1}: integer → 1 * 1.5 = 1.5 → ceil → 2
+    expect(scaled.cookware[0]!.quantity).toEqual({
+      type: "fixed",
+      value: { type: "decimal", decimal: 2 },
+    });
+    // sticks{2.5}: non-integer → 2.5 * 1.5 = 3.75, no rounding
+    expect(scaled.cookware[1]!.quantity).toEqual({
+      type: "fixed",
+      value: { type: "decimal", decimal: 3.75 },
+    });
+    // oven: no quantity → stays undefined
+    expect(scaled.cookware[2]!.quantity).toBeUndefined();
+  });
+
+  it("should scale down cookware quantities applying minimum 1 for integers", () => {
+    const scaled = baseRecipe.scaleBy(0.5);
+    // bowl{1}: integer → 1 * 0.5 = 0.5 → ceil → 1 → max(1, 1) = 1
+    expect(scaled.cookware[0]!.quantity).toEqual({
+      type: "fixed",
+      value: { type: "decimal", decimal: 1 },
+    });
+    // sticks{2.5}: non-integer → 2.5 * 0.5 = 1.25, no rounding
+    expect(scaled.cookware[1]!.quantity).toEqual({
+      type: "fixed",
+      value: { type: "decimal", decimal: 1.25 },
+    });
+    // oven: no quantity → stays undefined
+    expect(scaled.cookware[2]!.quantity).toBeUndefined();
+  });
+
+  it("should also scale CookwareItem.quantity in steps", () => {
+    const scaled = baseRecipe.scaleBy(1.5);
+    const step = scaled.sections[0]!.content[0] as Step;
+    const bowlItem = step.items[0] as CookwareItem;
+    const sticksItem = step.items[1] as CookwareItem;
+    const ovenItem = step.items[2] as CookwareItem;
+    // bowl: integer → ceil(1.5) = 2
+    expect(bowlItem.quantity).toEqual({
+      type: "fixed",
+      value: { type: "decimal", decimal: 2 },
+    });
+    // sticks: non-integer → 3.75
+    expect(sticksItem.quantity).toEqual({
+      type: "fixed",
+      value: { type: "decimal", decimal: 3.75 },
+    });
+    // oven: no quantity
+    expect(ovenItem.quantity).toBeUndefined();
+  });
+
+  it("should scale integer range cookware quantities, ceiling each bound", () => {
+    const recipe = new Recipe("#pans{1-2}");
+    const scaled = recipe.scaleBy(1.5);
+    // 1 * 1.5 = 1.5 → ceil → 2; 2 * 1.5 = 3 → ceil → 3
+    expect(scaled.cookware[0]!.quantity).toEqual({
+      type: "range",
+      min: { type: "decimal", decimal: 2 },
+      max: { type: "decimal", decimal: 3 },
+    });
+  });
+
+  it("should not apply ceiling to non-integer range cookware", () => {
+    const recipe = new Recipe("#pans{1.5-2.5}");
+    const scaled = recipe.scaleBy(2);
+    // non-integer range: 1.5*2=3, 2.5*2=5 — no ceiling
+    expect(scaled.cookware[0]!.quantity).toEqual({
+      type: "range",
+      min: { type: "decimal", decimal: 3 },
+      max: { type: "decimal", decimal: 5 },
+    });
+  });
+
+  it("should not modify the original recipe when scaling cookware", () => {
+    const original = baseRecipe.clone();
+    baseRecipe.scaleBy(2);
+    expect(baseRecipe).toEqual(original);
+  });
+
+  it("should leave text cookware quantities unchanged", () => {
+    const recipe = new Recipe("#bowl{some}");
+    const scaled = recipe.scaleBy(3);
+    expect(scaled.cookware[0]!.quantity).toEqual({
+      type: "fixed",
+      value: { type: "text", text: "some" },
+    });
+  });
+});