mcp-recipes 1.0.0

package/dist/language-BgfmjwtF.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Which language an ingredient line is written in.
+ *
+ * A list can hold French lines and English lines at once, because a cook
+ * comparing two versions of a dish keeps both in front of them. The language
+ * decides how a number is written, how a noun agrees with it, and which
+ * vocabulary of measures applies, so it is settled per line rather than once
+ * for a whole list.
+ */
+type Language = "fr" | "en";
+/** What a caller may ask for: a language, or a reading taken per line. */
+type LanguageChoice = Language | "auto";
+
+export type { LanguageChoice as L, Language as a };

package/dist/recipe/scale.d.ts

@@ -0,0 +1,86 @@
+import { L as LanguageChoice, a as Language } from '../language-BgfmjwtF.js';
+
+/**
+ * Scaling ingredient quantities, in French and in English.
+ *
+ * The guiding rule is that a scaled quantity must be something a cook can act
+ * on. Multiplying every number by the factor is arithmetically correct and
+ * practically useless: it produces "2,4 oeufs" and "0.67 pinch of salt" with
+ * the same confidence as "267 g flour". Each line is therefore classified by
+ * what its measure allows, and the classification travels with the result so
+ * the caller can see what was computed and what was left alone.
+ *
+ * Leaving a line alone is a decision of the same weight. A quantity a recipe
+ * states loosely still holds a share of the dish, and a leavening agent left at
+ * one pinch for twenty-five servings is a recipe that does not rise.
+ *
+ * The two languages are read by one set of rules. A list holding French lines
+ * and English lines comes back scaled by the same arithmetic, with each line
+ * written the way its own language writes numbers, plurals and measures.
+ */
+
+type ScalingKind = 
+/** The arithmetic was exact. */
+"scaled"
+/**
+ * A countable item was moved to a whole or half unit, or a measurement was
+ * demoted to a smaller unit to stay usable.
+ */
+ | "rounded"
+/** The line carries nothing that can be multiplied. */
+ | "unscaled";
+interface ScaledIngredient {
+    /** The line after scaling, identical to `original` when unscaled. */
+    text: string;
+    /** The line as published. */
+    original: string;
+    scaling: ScalingKind;
+    /**
+     * The scaled quantity, expressed in `unit`, and the lower bound when the line
+     * gives a range.
+     *
+     * Read it together with `unit`, never on its own: a large result is moved to
+     * a bigger unit, so scaling "200 g" by ten gives an amount of 2 with a unit
+     * of "kg". The bare number can therefore shrink while the quantity grows.
+     */
+    amount: number | null;
+    /** Upper bound when the line gives a range, null otherwise. */
+    amountMax: number | null;
+    /** The unit `amount` is in, which may differ from the one the recipe used. */
+    unit: string | null;
+    /** The language the line was read and rewritten in. */
+    language: Language;
+    /** Why the line was rounded, clamped or left alone. */
+    note?: string;
+}
+interface ScaleOptions {
+    /** Multiplier applied to the quantities. */
+    factor: number;
+    /**
+     * Which language to read the lines in. Left out, each line is read on its
+     * own, so a list holding both comes back written the way each line was.
+     */
+    language?: LanguageChoice;
+}
+/**
+ * Scale one ingredient line.
+ *
+ * Countable items are rounded to something a kitchen can measure, ranges are
+ * scaled at both ends, equivalents and alternatives are scaled with the amount
+ * they stand beside, and an approximate measure such as a pinch has its count
+ * scaled with a note saying how loosely one of them is defined.
+ */
+declare function scaleIngredient(line: string, options: ScaleOptions): ScaledIngredient;
+declare function scaleIngredients(lines: string[], options: ScaleOptions): ScaledIngredient[];
+/**
+ * A line returned as published, with whatever quantity could be read off it.
+ *
+ * A line that carries a readable amount is `scaled`, because leaving it alone
+ * is what multiplying by one does. A line with no amount at all is `unscaled`
+ * and says why.
+ */
+declare function passthroughIngredient(line: string, language?: LanguageChoice): ScaledIngredient;
+/** An ingredient list returned unchanged, for when no scaling was requested. */
+declare function passthroughIngredients(lines: string[], language?: LanguageChoice): ScaledIngredient[];
+
+export { Language, LanguageChoice, type ScaleOptions, type ScaledIngredient, type ScalingKind, passthroughIngredient, passthroughIngredients, scaleIngredient, scaleIngredients };