feat: ranges and fractions for ingredients and timers

Resolves: #3
Resolves: #6

Author: tmlmt

src/classes/recipe.ts

@@ -21,9 +21,10 @@ import {
   flushPendingNote,
   findAndUpsertIngredient,
   findAndUpsertCookware,
-  parseNumber,
+  parseQuantityInput,
   extractMetadata,
 } from "../parser_helpers";
+import { multiplyQuantityValue } from "../units";
 
 /**
  * Represents a recipe.
@@ -161,7 +162,9 @@ export class Recipe {
           const hidden = modifier === "-";
           const reference = modifier === "&";
           const isRecipe = modifier === "@";
-          const quantity = quantityRaw ? parseNumber(quantityRaw) : undefined;
+          const quantity = quantityRaw
+            ? parseQuantityInput(quantityRaw)
+            : undefined;
 
           const idxInList = findAndUpsertIngredient(
             this.ingredients,
@@ -208,7 +211,7 @@ export class Recipe {
             throw new Error("Timer missing units");
           }
           const name = groups.timerName || undefined;
-          const duration = parseNumber(durationStr);
+          const duration = parseQuantityInput(durationStr);
           const timerObj: Timer = {
             name,
             duration,
@@ -275,8 +278,17 @@ export class Recipe {
 
     newRecipe.ingredients = newRecipe.ingredients
       .map((ingredient) => {
-        if (ingredient.quantity && !isNaN(Number(ingredient.quantity))) {
-          (ingredient.quantity as number) *= factor;
+        if (
+          ingredient.quantity &&
+          !(
+            ingredient.quantity.type === "fixed" &&
+            ingredient.quantity.value.type === "text"
+          )
+        ) {
+          ingredient.quantity = multiplyQuantityValue(
+            ingredient.quantity,
+            factor,
+          );
         }
         return ingredient;
       })

src/classes/shopping_list.ts

@@ -6,7 +6,7 @@ import type {
   AddedRecipe,
   AddedIngredient,
 } from "../types";
-import { addQuantities } from "../units";
+import { addQuantities, type Quantity } from "../units";
 
 /**
  * Represents a shopping list.
@@ -61,7 +61,7 @@ export class ShoppingList {
         try {
           if (existingIngredient) {
             if (existingIngredient.quantity && ingredient.quantity) {
-              const newQuantity = addQuantities(
+              const newQuantity: Quantity = addQuantities(
                 {
                   value: existingIngredient.quantity,
                   unit: existingIngredient.unit ?? "",

src/index.ts

@@ -5,6 +5,11 @@ import type {
   Metadata,
   MetadataExtract,
   Ingredient,
+  FixedValue,
+  Range,
+  DecimalValue,
+  FractionValue,
+  TextValue,
   Timer,
   TextItem,
   IngredientItem,
@@ -27,6 +32,11 @@ export {
   Metadata,
   MetadataExtract,
   Ingredient,
+  FixedValue,
+  Range,
+  DecimalValue,
+  FractionValue,
+  TextValue,
   Timer,
   TextItem,
   IngredientItem,

src/parser_helpers.ts

@@ -1,8 +1,21 @@
-import type { MetadataExtract, Metadata } from "./types";
-import { metadataRegex } from "./regex";
+import type {
+  MetadataExtract,
+  Metadata,
+  FixedValue,
+  Range,
+  TextValue,
+  DecimalValue,
+  FractionValue,
+} from "./types";
+import { metadataRegex, rangeRegex, numberLikeRegex } from "./regex";
 import { Section as SectionObject } from "./classes/section";
 import type { Ingredient, Note, Step, Cookware } from "./types";
-import { addQuantities } from "./units";
+import {
+  addQuantities,
+  CannotAddTextValueError,
+  IncompatibleUnitsError,
+  Quantity,
+} from "./units";
 
 /**
  * Finds an item in a list or adds it if not present, then returns its index.
@@ -88,15 +101,28 @@ export function findAndUpsertIngredient(
     // Ingredient already exists, update it
     const existingIngredient = ingredients[index]!;
     if (quantity !== undefined) {
-      const currentQuantity = {
-        value: existingIngredient.quantity ?? 0,
+      const currentQuantity: Quantity = {
+        value: existingIngredient.quantity ?? {
+          type: "fixed",
+          value: { type: "decimal", value: 0 },
+        },
         unit: existingIngredient.unit ?? "",
       };
       const newQuantity = { value: quantity, unit: unit ?? "" };
 
-      const total = addQuantities(currentQuantity, newQuantity);
-      existingIngredient.quantity = total.value;
-      existingIngredient.unit = total.unit || undefined;
+      try {
+        const total = addQuantities(currentQuantity, newQuantity);
+        existingIngredient.quantity = total.value;
+        existingIngredient.unit = total.unit || undefined;
+      } catch (e) {
+        if (
+          e instanceof IncompatibleUnitsError ||
+          e instanceof CannotAddTextValueError
+        ) {
+          // Addition not possible, so add as a new ingredient.
+          return ingredients.push(newIngredient) - 1;
+        }
+      }
     }
     return index;
   }
@@ -129,18 +155,52 @@ export function findAndUpsertCookware(
   return cookware.push(newCookware) - 1;
 }
 
-export function parseNumber(input_str: string): number {
-  const clean_str = String(input_str).replace(",", ".");
-  if (!clean_str.startsWith("/") && clean_str.includes("/")) {
-    const [num, den] = clean_str.split("/").map(Number);
-    return num! / den!;
+// Parser when we know the input is either a number-like value
+const parseFixedValue = (
+  input_str: string,
+): TextValue | DecimalValue | FractionValue => {
+  if (!numberLikeRegex.test(input_str)) {
+    return { type: "text", value: input_str };
   }
-  return Number(clean_str);
+
+  // After this we know that s is either a fraction or a decimal value
+  const s = input_str.trim().replace(",", ".");
+
+  // fraction
+  if (s.includes("/")) {
+    const parts = s.split("/");
+
+    const num = Number(parts[0]);
+    const den = Number(parts[1]);
+
+    return { type: "fraction", num, den };
+  }
+
+  // decimal
+  return { type: "decimal", value: Number(s) };
+};
+
+export function parseQuantityInput(input_str: string): FixedValue | Range {
+  const clean_str = String(input_str).trim();
+
+  if (rangeRegex.test(clean_str)) {
+    const range_parts = clean_str.split("-");
+    // As we've tested for it, we know that we have Number-like Quantities to parse
+    const min = parseFixedValue(range_parts[0]!.trim()) as
+      | DecimalValue
+      | FractionValue;
+    const max = parseFixedValue(range_parts[1]!.trim()) as
+      | DecimalValue
+      | FractionValue;
+    return { type: "range", min, max };
+  }
+
+  return { type: "fixed", value: parseFixedValue(clean_str) };
 }
 
 export function parseSimpleMetaVar(content: string, varName: string) {
   const varMatch = content.match(
-    new RegExp(`^${varName}:\\s*(.*(?:\\r?\\n\\s+.*)*)+`, "m"),
+    new RegExp(`^${varName}:\s*(.*(?:\r?\n\s+.*)*)+`, "m"),
   );
   return varMatch
     ? varMatch[1]?.trim().replace(/\s*\r?\n\s+/g, " ")
@@ -149,7 +209,7 @@ export function parseSimpleMetaVar(content: string, varName: string) {
 
 export function parseScalingMetaVar(content: string, varName: string) {
   const varMatch = content.match(
-    new RegExp(`^${varName}:[\\t ]*(([^,\\n]*),? ?(?:.*)?)`, "m"),
+    new RegExp(`^${varName}:[\t ]*(([^,\n]*),? ?(?:.*)?)`, "m"),
   );
   if (!varMatch) return undefined;
   if (isNaN(Number(varMatch[2]?.trim()))) {
@@ -161,10 +221,7 @@ export function parseScalingMetaVar(content: string, varName: string) {
 export function parseListMetaVar(content: string, varName: string) {
   // Handle both inline and YAML-style tags
   const listMatch = content.match(
-    new RegExp(
-      `^${varName}:\\s*(?:\\[([^\\]]*)\\]|((?:\\r?\\n\\s*-\\s*.+)+))`,
-      "m",
-    ),
+    new RegExp(`^${varName}:\s*(?:[([^]]*)]|((?:\r?\n\s*-\s*.+)+))`, "m"),
   );
   if (!listMatch) return undefined;
 

src/regex.ts

@@ -23,15 +23,7 @@ const multiwordIngredient = createRegex()
   .startGroup()
     .literal("{")
     .startNamedGroup("mIngredientQuantity")
-      .unicodeDigit().oneOrMore()
-       .or()
-      .startGroup()
-        .unicodeDigit().oneOrMore()
-        .startGroup()
-          .anyOf("\\.,\\/")
-          .unicodeDigit().oneOrMore()
-        .endGroup().optional()
-      .endGroup()
+      .notAnyOf("}%").oneOrMore()
     .endGroup().optional()
     .startGroup()
       .literal("%")
@@ -61,15 +53,7 @@ const singleWordIngredient = createRegex()
   .startGroup()
     .literal("{")
     .startNamedGroup("sIngredientQuantity")
-      .unicodeDigit().oneOrMore()
-       .or()
-      .startGroup()
-        .unicodeDigit().oneOrMore()
-        .startGroup()
-          .anyOf("\\.,\\/")
-          .unicodeDigit().oneOrMore()
-        .endGroup().optional()
-      .endGroup()
+      .notAnyOf("}%").oneOrMore()
     .endGroup().optional()
     .startGroup()
       .literal("%")
@@ -186,3 +170,28 @@ export const shoppingListRegex = createRegex()
   .endGroup()
   .global()
   .toRegExp()
+
+export const rangeRegex = createRegex()
+  .startAnchor()
+  .digit().oneOrMore()
+  .startGroup()
+  .anyOf(".,/").exactly(1)
+    .digit().oneOrMore()
+  .endGroup().optional()
+  .literal("-")
+  .startGroup()
+    .anyOf(".,/").exactly(1)
+    .digit().oneOrMore()
+  .endGroup().optional()
+  .endAnchor()
+  .toRegExp()
+
+export const numberLikeRegex = createRegex()
+  .startAnchor()
+  .digit().oneOrMore()
+  .startGroup()
+    .anyOf(".,/").exactly(1)
+    .digit().oneOrMore()
+  .endGroup().optional()
+  .endAnchor()
+  .toRegExp()

src/types.ts

@@ -85,6 +85,56 @@ export interface MetadataExtract {
   servings?: number;
 }
 
+/**
+ * Represents a quantity described by text, e.g. "a pinch"
+ * @category Types
+ */
+export interface TextValue {
+  type: "text";
+  value: string;
+}
+
+/**
+ * Represents a quantity described by a decimal number, e.g. "1.5"
+ * @category Types
+ */
+export interface DecimalValue {
+  type: "decimal";
+  value: number;
+}
+
+/**
+ * Represents a quantity described by a fraction, e.g. "1/2"
+ * @category Types
+ */
+export interface FractionValue {
+  type: "fraction";
+  /** The numerator of the fraction */
+  num: number;
+  /** The denominator of the fraction */
+  den: number;
+}
+
+/**
+ * Represents a single, fixed quantity.
+ * This can be a text, decimal, or fraction.
+ * @category Types
+ */
+export interface FixedValue {
+  type: "fixed";
+  value: TextValue | DecimalValue | FractionValue;
+}
+
+/**
+ * Represents a range of quantities, e.g. "1-2"
+ * @category Types
+ */
+export interface Range {
+  type: "range";
+  min: DecimalValue | FractionValue;
+  max: DecimalValue | FractionValue;
+}
+
 /**
  * Represents an ingredient in a recipe.
  * @category Types
@@ -93,7 +143,7 @@ export interface Ingredient {
   /** The name of the ingredient. */
   name: string;
   /** The quantity of the ingredient. */
-  quantity?: number | string;
+  quantity?: FixedValue | Range;
   /** The unit of the ingredient. */
   unit?: string;
   /** The preparation of the ingredient. */
@@ -114,7 +164,7 @@ export interface Timer {
   /** The name of the timer. */
   name?: string;
   /** The duration of the timer. */
-  duration: number;
+  duration: FixedValue | Range;
   /** The unit of the timer. */
   unit: string;
 }
@@ -140,7 +190,7 @@ export interface IngredientItem {
   /** The value of the item. */
   value: number;
   /** If this is a referenced ingredient, quantity specific to this instance */
-  partialQuantity?: number | string;
+  partialQuantity?: FixedValue | Range;
   /** If this is a referenced ingredient, unit specific to this instance  */
   partialUnit?: string;
   /** If this is a referenced ingredient, preparation specific to this instance  */