healthy-meals-core 0.0.2

package/dist/foodConversion.d.ts

@@ -0,0 +1,55 @@
+import { NormalizedFoodItem } from './types/openfoodfacts';
+import { Meal, Ingredient } from './types/firestore';
+export interface ExtendedIngredient extends Ingredient {
+    barcode?: string;
+    brand?: string;
+    nutritionGrade?: string;
+    ecoScore?: string;
+    allergens?: string[];
+}
+/**
+ * Convert Open Food Facts item to Ingredient for meal planning
+ */
+export declare function convertFoodItemToIngredient(foodItem: NormalizedFoodItem, amount?: number, unit?: string): Ingredient;
+/**
+ * Calculate total nutrition for a list of ingredients
+ */
+export declare function calculateTotalNutrition(ingredients: Ingredient[]): {
+    calories: number;
+    protein: number;
+    carbs: number;
+    fat: number;
+    fiber: number;
+    sugar: number;
+    sodium: number;
+};
+/**
+ * Create a meal from selected food items
+ */
+export declare function createMealFromFoodItems(name: string, type: 'breakfast' | 'lunch' | 'dinner' | 'snack', foodItems: Array<{
+    food: NormalizedFoodItem;
+    amount: number;
+    unit: string;
+}>): Meal;
+/**
+ * Get nutrition density score (protein per calorie ratio)
+ */
+export declare function getNutritionDensityScore(foodItem: NormalizedFoodItem): number;
+/**
+ * Check if food item meets dietary restrictions
+ */
+export declare function checkDietaryRestrictions(foodItem: NormalizedFoodItem, restrictions: string[]): {
+    meets: boolean;
+    violations: string[];
+};
+/**
+ * Get recommended serving size based on meal type and nutrition goals
+ */
+export declare function getRecommendedServingSize(foodItem: NormalizedFoodItem, mealType: 'breakfast' | 'lunch' | 'dinner' | 'snack', targetCalories?: number): {
+    amount: number;
+    unit: string;
+};
+/**
+ * Filter foods by health goals
+ */
+export declare function filterFoodsByHealthGoals(foods: NormalizedFoodItem[], healthGoals: string[]): NormalizedFoodItem[];

package/dist/foodConversion.js

@@ -0,0 +1,200 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.filterFoodsByHealthGoals = exports.getRecommendedServingSize = exports.checkDietaryRestrictions = exports.getNutritionDensityScore = exports.createMealFromFoodItems = exports.calculateTotalNutrition = exports.convertFoodItemToIngredient = void 0;
+/**
+ * Convert Open Food Facts item to Ingredient for meal planning
+ */
+function convertFoodItemToIngredient(foodItem, amount = 100, unit = 'g') {
+    // Calculate nutrition values based on amount (default is per 100g)
+    const multiplier = amount / 100;
+    return {
+        id: `${foodItem.name.toLowerCase().replace(/\s+/g, '-')}-${Date.now()}`,
+        name: foodItem.name,
+        quantity: amount,
+        unit,
+        calories: Math.round((foodItem.nutritionPer100g?.calories || 0) * multiplier) || 0,
+        protein: Math.round(((foodItem.nutritionPer100g?.protein || 0) * multiplier * 10)) / 10 || 0,
+        carbs: Math.round(((foodItem.nutritionPer100g?.carbs || 0) * multiplier * 10)) / 10 || 0,
+        fat: Math.round(((foodItem.nutritionPer100g?.fat || 0) * multiplier * 10)) / 10 || 0,
+        fiber: Math.round(((foodItem.nutritionPer100g?.fiber || 0) * multiplier * 10)) / 10 || 0,
+        sugar: Math.round(((foodItem.nutritionPer100g?.sugar || 0) * multiplier * 10)) / 10 || 0,
+        sodium: Math.round(((foodItem.nutritionPer100g?.sodium || 0) * multiplier * 10)) / 10 || 0,
+    };
+}
+exports.convertFoodItemToIngredient = convertFoodItemToIngredient;
+/**
+ * Calculate total nutrition for a list of ingredients
+ */
+function calculateTotalNutrition(ingredients) {
+    return ingredients.reduce((total, ingredient) => ({
+        calories: total.calories + (ingredient.calories || 0),
+        protein: Math.round((total.protein + (ingredient.protein || 0)) * 10) / 10,
+        carbs: Math.round((total.carbs + (ingredient.carbs || 0)) * 10) / 10,
+        fat: Math.round((total.fat + (ingredient.fat || 0)) * 10) / 10,
+        fiber: Math.round((total.fiber + (ingredient.fiber || 0)) * 10) / 10,
+        sugar: Math.round((total.sugar + (ingredient.sugar || 0)) * 10) / 10,
+        sodium: Math.round((total.sodium + (ingredient.sodium || 0)) * 10) / 10,
+    }), { calories: 0, protein: 0, carbs: 0, fat: 0, fiber: 0, sugar: 0, sodium: 0 });
+}
+exports.calculateTotalNutrition = calculateTotalNutrition;
+/**
+ * Create a meal from selected food items
+ */
+function createMealFromFoodItems(name, type, foodItems) {
+    const ingredients = foodItems.map(({ food, amount, unit }) => convertFoodItemToIngredient(food, amount, unit));
+    const nutrition = calculateTotalNutrition(ingredients);
+    return {
+        id: `${type}-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+        name,
+        type,
+        ingredients,
+        nutrition: {
+            calories: nutrition.calories,
+            protein: nutrition.protein,
+            carbs: nutrition.carbs,
+            fat: nutrition.fat,
+            fiber: nutrition.fiber,
+            sugar: nutrition.sugar,
+            sodium: nutrition.sodium,
+        },
+        instructions: [],
+        prepTime: 15,
+        cookTime: 20,
+        servings: 1,
+        tags: [type],
+        difficulty: 'easy',
+        createdAt: new Date(),
+        updatedAt: new Date(),
+    };
+}
+exports.createMealFromFoodItems = createMealFromFoodItems;
+/**
+ * Get nutrition density score (protein per calorie ratio)
+ */
+function getNutritionDensityScore(foodItem) {
+    if (foodItem.nutritionPer100g.calories === 0)
+        return 0;
+    return foodItem.nutritionPer100g.protein / foodItem.nutritionPer100g.calories;
+}
+exports.getNutritionDensityScore = getNutritionDensityScore;
+/**
+ * Check if food item meets dietary restrictions
+ */
+function checkDietaryRestrictions(foodItem, restrictions) {
+    const violations = [];
+    // Check categories for dietary restrictions
+    const categories = foodItem.categories?.map(c => c.toLowerCase()) || [];
+    const ingredients = foodItem.ingredients?.toLowerCase() || '';
+    const allergens = foodItem.allergens?.map(a => a.toLowerCase()) || [];
+    restrictions.forEach(restriction => {
+        const restrictionLower = restriction.toLowerCase();
+        switch (restrictionLower) {
+            case 'vegetarian':
+                if (categories.some((cat) => cat.includes('meat') || cat.includes('fish') || cat.includes('poultry'))) {
+                    violations.push('Contains meat/fish');
+                }
+                break;
+            case 'vegan':
+                if (categories.some((cat) => cat.includes('meat') || cat.includes('fish') || cat.includes('dairy') ||
+                    cat.includes('eggs') || cat.includes('honey')) || ingredients.includes('milk') || ingredients.includes('egg')) {
+                    violations.push('Contains animal products');
+                }
+                break;
+            case 'gluten-free':
+                if (allergens.includes('gluten') || ingredients.includes('wheat') ||
+                    ingredients.includes('barley') || ingredients.includes('rye')) {
+                    violations.push('Contains gluten');
+                }
+                break;
+            case 'dairy-free':
+                if (allergens.includes('milk') || categories.some((cat) => cat.includes('dairy')) ||
+                    ingredients.includes('milk') || ingredients.includes('lactose')) {
+                    violations.push('Contains dairy');
+                }
+                break;
+            case 'nut-free':
+                if (allergens.some((a) => a.includes('nut')) || ingredients.includes('nuts')) {
+                    violations.push('Contains nuts');
+                }
+                break;
+        }
+    });
+    return {
+        meets: violations.length === 0,
+        violations
+    };
+}
+exports.checkDietaryRestrictions = checkDietaryRestrictions;
+/**
+ * Get recommended serving size based on meal type and nutrition goals
+ */
+function getRecommendedServingSize(foodItem, mealType, targetCalories) {
+    // Default serving size from product data
+    if (foodItem.servingSize) {
+        const match = foodItem.servingSize.match(/(\d+(?:\.\d+)?)\s*(\w+)/);
+        if (match) {
+            return {
+                amount: parseFloat(match[1]),
+                unit: match[2]
+            };
+        }
+    }
+    // Calculate based on target calories if provided
+    if (targetCalories && foodItem.nutritionPer100g.calories > 0) {
+        const amount = Math.round((targetCalories / foodItem.nutritionPer100g.calories) * 100);
+        return { amount, unit: 'g' };
+    }
+    // Default serving sizes by meal type
+    const defaultServings = {
+        breakfast: 150,
+        lunch: 200,
+        dinner: 200,
+        snack: 50 // g
+    };
+    return {
+        amount: defaultServings[mealType],
+        unit: 'g'
+    };
+}
+exports.getRecommendedServingSize = getRecommendedServingSize;
+/**
+ * Filter foods by health goals
+ */
+function filterFoodsByHealthGoals(foods, healthGoals) {
+    return foods.filter(food => {
+        for (const goal of healthGoals) {
+            switch (goal.toLowerCase()) {
+                case 'weight_loss':
+                    // Prefer low-calorie, high-protein foods
+                    if (food.nutritionPer100g.calories > 300 ||
+                        getNutritionDensityScore(food) < 0.05) {
+                        return false;
+                    }
+                    break;
+                case 'muscle_gain':
+                    // Prefer high-protein foods
+                    if (food.nutritionPer100g.protein < 10) {
+                        return false;
+                    }
+                    break;
+                case 'heart_health':
+                    // Prefer foods with good nutrition grades and low sodium
+                    if (food.nutritionGrade && !['a', 'b'].includes(food.nutritionGrade.toLowerCase())) {
+                        return false;
+                    }
+                    if (food.nutritionPer100g.sodium && food.nutritionPer100g.sodium > 600) {
+                        return false;
+                    }
+                    break;
+                case 'diabetes_management':
+                    // Prefer low-sugar, high-fiber foods
+                    if (food.nutritionPer100g.sugar && food.nutritionPer100g.sugar > 15) {
+                        return false;
+                    }
+                    break;
+            }
+        }
+        return true;
+    });
+}
+exports.filterFoodsByHealthGoals = filterFoodsByHealthGoals;

package/dist/index.d.ts

@@ -0,0 +1,12 @@
+export { UserProfile, HealthCondition, Gender } from './types';
+export * from './bmr';
+export * from './planner';
+export * from './rules';
+export * from './weeklyPlanner';
+export * from './variety';
+export * from './dailyMealPlanGenerator';
+export * from './weeklyMealPlanGenerator';
+export * from './foodConversion';
+export * from './types/recipe';
+export * from './recipeService';
+export * from './recipeBasedMealPlanGenerator';

package/dist/index.js

@@ -0,0 +1,27 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./bmr"), exports);
+__exportStar(require("./planner"), exports);
+__exportStar(require("./rules"), exports);
+__exportStar(require("./weeklyPlanner"), exports);
+__exportStar(require("./variety"), exports);
+__exportStar(require("./dailyMealPlanGenerator"), exports);
+__exportStar(require("./weeklyMealPlanGenerator"), exports);
+__exportStar(require("./foodConversion"), exports);
+__exportStar(require("./types/recipe"), exports);
+__exportStar(require("./recipeService"), exports);
+__exportStar(require("./recipeBasedMealPlanGenerator"), exports);

package/dist/planner.d.ts

@@ -0,0 +1,2 @@
+import { Recipe, MealPlan, UserProfile } from './types';
+export declare function generateDailyPlan(profile: UserProfile, recipes: Recipe[]): MealPlan;

package/dist/planner.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateDailyPlan = void 0;
+const bmr_1 = require("./bmr");
+const rules_1 = require("./rules");
+function generateDailyPlan(profile, recipes) {
+    const targetCalories = Math.round((0, bmr_1.calculateTDEE)(profile));
+    const filtered = (0, rules_1.applyHealthRules)(recipes, profile.conditions);
+    let total = 0;
+    const meals = [];
+    for (const recipe of filtered) {
+        if (total + recipe.calories <= targetCalories) {
+            meals.push(recipe);
+            total += recipe.calories;
+        }
+        if (total >= targetCalories * 0.95)
+            break;
+    }
+    return {
+        dailyCalories: total,
+        meals
+    };
+}
+exports.generateDailyPlan = generateDailyPlan;

package/dist/recipeBasedMealPlanGenerator.d.ts

@@ -0,0 +1,17 @@
+import { UserProfile, MealPlan, Meal } from './types/firestore';
+import { Recipe } from './types/recipe';
+/**
+ * Generate a daily meal plan using recipes from the recipe database
+ * Each meal will have complete ingredients and cooking instructions
+ */
+export declare function generateDailyMealPlanWithRecipes(profile: UserProfile, userId: string): MealPlan;
+/**
+ * Generate a weekly meal plan using recipes from the recipe database
+ * Each day will have 4 meals with complete ingredients and cooking instructions
+ */
+export declare function generateWeeklyMealPlanWithRecipes(profile: UserProfile, userId: string): MealPlan;
+/**
+ * Get recipe details for a meal in a meal plan
+ * This allows you to retrieve the full recipe with instructions for any meal
+ */
+export declare function getRecipeForMeal(meal: Meal): Recipe | undefined;

package/dist/recipeBasedMealPlanGenerator.js

@@ -0,0 +1,255 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRecipeForMeal = exports.generateWeeklyMealPlanWithRecipes = exports.generateDailyMealPlanWithRecipes = void 0;
+const recipeService_1 = require("./recipeService");
+function calculateDailyNeeds(profile) {
+    const age = profile.age || 30;
+    const height = profile.height || 170;
+    const weight = profile.weight || 70;
+    const gender = profile.gender || 'male';
+    const activityLevel = profile.activityLevel || 'moderately_active';
+    const bmr = gender === 'male'
+        ? 88.362 + (13.397 * weight) + (4.799 * height) - (5.677 * age)
+        : 447.593 + (9.247 * weight) + (3.098 * height) - (4.330 * age);
+    const activityMultipliers = {
+        sedentary: 1.2,
+        lightly_active: 1.375,
+        moderately_active: 1.55,
+        very_active: 1.725,
+        extremely_active: 1.9
+    };
+    const tdee = bmr * (activityMultipliers[activityLevel] || 1.2);
+    let dailyCalories = tdee;
+    if (profile.healthGoals?.includes('weight_loss')) {
+        dailyCalories -= 500;
+    }
+    else if (profile.healthGoals?.includes('weight_gain')) {
+        dailyCalories += 500;
+    }
+    return {
+        calories: Math.round(Math.max(dailyCalories, 1200)),
+        protein: Math.round(Math.max(dailyCalories * 0.3 / 4, 50)),
+        carbs: Math.round(Math.max(dailyCalories * 0.4 / 4, 100)),
+        fat: Math.round(Math.max(dailyCalories * 0.3 / 9, 30))
+    };
+}
+function convertRecipeToMeal(recipe) {
+    return {
+        id: recipe.id,
+        name: recipe.name,
+        type: recipe.category,
+        ingredients: recipe.ingredients.map(ing => ({
+            id: `${recipe.id}-${ing.name}`,
+            name: ing.name,
+            quantity: ing.quantity,
+            unit: ing.unit,
+            calories: 0,
+            protein: 0,
+            carbs: 0,
+            fat: 0,
+            fiber: 0,
+            sugar: 0,
+            sodium: 0
+        })),
+        instructions: recipe.instructions,
+        prepTime: recipe.prepTime,
+        cookTime: recipe.cookTime,
+        servings: recipe.servings,
+        nutrition: {
+            calories: recipe.nutrition.calories,
+            protein: recipe.nutrition.protein,
+            carbs: recipe.nutrition.carbs,
+            fat: recipe.nutrition.fat,
+            fiber: recipe.nutrition.fiber,
+            sugar: recipe.nutrition.sugar,
+            sodium: recipe.nutrition.sodium
+        },
+        tags: recipe.tags,
+        difficulty: recipe.difficulty,
+        createdAt: new Date(),
+        updatedAt: new Date()
+    };
+}
+/**
+ * Generate a daily meal plan using recipes from the recipe database
+ * Each meal will have complete ingredients and cooking instructions
+ */
+function generateDailyMealPlanWithRecipes(profile, userId) {
+    const needs = calculateDailyNeeds(profile);
+    // Get recipes filtered by user preferences
+    let availableRecipes = recipeService_1.recipeService.getAllRecipes();
+    // Filter by dietary restrictions
+    if (profile.dietaryRestrictions && profile.dietaryRestrictions.length > 0) {
+        availableRecipes = recipeService_1.recipeService.getRecipesForDietaryRestrictions(profile.dietaryRestrictions);
+    }
+    // Filter by health goals
+    if (profile.healthGoals && profile.healthGoals.length > 0) {
+        const healthRecipes = recipeService_1.recipeService.getRecipesForHealthGoals(profile.healthGoals);
+        availableRecipes = availableRecipes.filter(r => healthRecipes.some(hr => hr.id === r.id));
+    }
+    // Filter by cooking time preference if available
+    if (profile.preferences?.cookingTime) {
+        availableRecipes = availableRecipes.filter(r => recipeService_1.recipeService.getTotalTime(r) <= profile.preferences.cookingTime);
+    }
+    // Select one recipe for each meal type
+    const breakfastRecipes = availableRecipes.filter(r => r.category === 'breakfast');
+    const lunchRecipes = availableRecipes.filter(r => r.category === 'lunch');
+    const dinnerRecipes = availableRecipes.filter(r => r.category === 'dinner');
+    const snackRecipes = availableRecipes.filter(r => r.category === 'snack');
+    // Pick random recipes or first available
+    const selectedRecipes = {
+        breakfast: breakfastRecipes.length > 0
+            ? breakfastRecipes[Math.floor(Math.random() * breakfastRecipes.length)]
+            : recipeService_1.recipeService.getRecipeById('breakfast-1'),
+        lunch: lunchRecipes.length > 0
+            ? lunchRecipes[Math.floor(Math.random() * lunchRecipes.length)]
+            : recipeService_1.recipeService.getRecipeById('lunch-1'),
+        dinner: dinnerRecipes.length > 0
+            ? dinnerRecipes[Math.floor(Math.random() * dinnerRecipes.length)]
+            : recipeService_1.recipeService.getRecipeById('dinner-1'),
+        snack: snackRecipes.length > 0
+            ? snackRecipes[Math.floor(Math.random() * snackRecipes.length)]
+            : recipeService_1.recipeService.getRecipeById('snack-1')
+    };
+    // Convert recipes to meals
+    const meals = [
+        convertRecipeToMeal(selectedRecipes.breakfast),
+        convertRecipeToMeal(selectedRecipes.lunch),
+        convertRecipeToMeal(selectedRecipes.dinner),
+        convertRecipeToMeal(selectedRecipes.snack)
+    ];
+    // Calculate total nutrition
+    const totalNutrition = meals.reduce((total, meal) => ({
+        calories: total.calories + (meal.nutrition?.calories || 0),
+        protein: Math.round((total.protein + (meal.nutrition?.protein || 0)) * 10) / 10,
+        carbs: Math.round((total.carbs + (meal.nutrition?.carbs || 0)) * 10) / 10,
+        fat: Math.round((total.fat + (meal.nutrition?.fat || 0)) * 10) / 10
+    }), { calories: 0, protein: 0, carbs: 0, fat: 0 });
+    const today = new Date();
+    return {
+        id: `daily-recipe-plan-${Date.now()}`,
+        userId: userId,
+        name: `Daily Meal Plan - ${today.toLocaleDateString()}`,
+        description: `Personalized daily meal plan with complete recipes (${Math.round(totalNutrition.calories)} cal)`,
+        startDate: today.toISOString().split('T')[0],
+        endDate: today.toISOString().split('T')[0],
+        dailyPlans: [],
+        meals,
+        totalCalories: totalNutrition.calories,
+        totalProtein: totalNutrition.protein,
+        totalCarbs: totalNutrition.carbs,
+        totalFat: totalNutrition.fat,
+        uid: userId,
+        goals: {
+            dailyCalories: needs.calories,
+            proteinPercentage: 25,
+            carbsPercentage: 45,
+            fatPercentage: 30,
+        },
+        createdAt: new Date(),
+        updatedAt: new Date()
+    };
+}
+exports.generateDailyMealPlanWithRecipes = generateDailyMealPlanWithRecipes;
+/**
+ * Generate a weekly meal plan using recipes from the recipe database
+ * Each day will have 4 meals with complete ingredients and cooking instructions
+ */
+function generateWeeklyMealPlanWithRecipes(profile, userId) {
+    const needs = calculateDailyNeeds(profile);
+    // Get recipes filtered by user preferences
+    let availableRecipes = recipeService_1.recipeService.getAllRecipes();
+    // Filter by dietary restrictions
+    if (profile.dietaryRestrictions && profile.dietaryRestrictions.length > 0) {
+        availableRecipes = recipeService_1.recipeService.getRecipesForDietaryRestrictions(profile.dietaryRestrictions);
+    }
+    // Filter by health goals
+    if (profile.healthGoals && profile.healthGoals.length > 0) {
+        const healthRecipes = recipeService_1.recipeService.getRecipesForHealthGoals(profile.healthGoals);
+        availableRecipes = availableRecipes.filter(r => healthRecipes.some(hr => hr.id === r.id));
+    }
+    // Filter by cooking time preference
+    if (profile.preferences?.cookingTime) {
+        availableRecipes = availableRecipes.filter(r => recipeService_1.recipeService.getTotalTime(r) <= profile.preferences.cookingTime);
+    }
+    // Separate by category
+    const breakfastRecipes = availableRecipes.filter(r => r.category === 'breakfast');
+    const lunchRecipes = availableRecipes.filter(r => r.category === 'lunch');
+    const dinnerRecipes = availableRecipes.filter(r => r.category === 'dinner');
+    const snackRecipes = availableRecipes.filter(r => r.category === 'snack');
+    const allMeals = [];
+    const daysOfWeek = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday'];
+    // Generate meals for each day
+    daysOfWeek.forEach((day, dayIndex) => {
+        // Select different recipes for variety (cycle through available recipes)
+        const breakfast = breakfastRecipes.length > 0
+            ? breakfastRecipes[dayIndex % breakfastRecipes.length]
+            : recipeService_1.recipeService.getRecipeById('breakfast-1');
+        const lunch = lunchRecipes.length > 0
+            ? lunchRecipes[dayIndex % lunchRecipes.length]
+            : recipeService_1.recipeService.getRecipeById('lunch-1');
+        const dinner = dinnerRecipes.length > 0
+            ? dinnerRecipes[dayIndex % dinnerRecipes.length]
+            : recipeService_1.recipeService.getRecipeById('dinner-1');
+        const snack = snackRecipes.length > 0
+            ? snackRecipes[dayIndex % snackRecipes.length]
+            : recipeService_1.recipeService.getRecipeById('snack-1');
+        // Convert to meals and add day prefix
+        const dayMeals = [
+            { ...convertRecipeToMeal(breakfast), name: `${day} - ${breakfast.name}` },
+            { ...convertRecipeToMeal(lunch), name: `${day} - ${lunch.name}` },
+            { ...convertRecipeToMeal(dinner), name: `${day} - ${dinner.name}` },
+            { ...convertRecipeToMeal(snack), name: `${day} - ${snack.name}` }
+        ];
+        allMeals.push(...dayMeals);
+    });
+    // Calculate total nutrition
+    const totalNutrition = allMeals.reduce((total, meal) => ({
+        calories: total.calories + (meal.nutrition?.calories || 0),
+        protein: Math.round((total.protein + (meal.nutrition?.protein || 0)) * 10) / 10,
+        carbs: Math.round((total.carbs + (meal.nutrition?.carbs || 0)) * 10) / 10,
+        fat: Math.round((total.fat + (meal.nutrition?.fat || 0)) * 10) / 10
+    }), { calories: 0, protein: 0, carbs: 0, fat: 0 });
+    const startDate = new Date();
+    const endDate = new Date();
+    endDate.setDate(startDate.getDate() + 6);
+    return {
+        id: `weekly-recipe-plan-${Date.now()}`,
+        userId: userId,
+        name: `Weekly Meal Plan - ${startDate.toLocaleDateString()} to ${endDate.toLocaleDateString()}`,
+        description: `7-day meal plan with complete recipes and instructions (${Math.round(totalNutrition.calories / 7)} cal/day avg)`,
+        startDate: startDate.toISOString().split('T')[0],
+        endDate: endDate.toISOString().split('T')[0],
+        dailyPlans: [],
+        meals: allMeals,
+        totalCalories: totalNutrition.calories,
+        totalProtein: totalNutrition.protein,
+        totalCarbs: totalNutrition.carbs,
+        totalFat: totalNutrition.fat,
+        uid: userId,
+        goals: {
+            dailyCalories: needs.calories,
+            proteinPercentage: 25,
+            carbsPercentage: 45,
+            fatPercentage: 30,
+        },
+        createdAt: new Date(),
+        updatedAt: new Date()
+    };
+}
+exports.generateWeeklyMealPlanWithRecipes = generateWeeklyMealPlanWithRecipes;
+/**
+ * Get recipe details for a meal in a meal plan
+ * This allows you to retrieve the full recipe with instructions for any meal
+ */
+function getRecipeForMeal(meal) {
+    // Try to find the recipe by ID (if meal ID matches recipe ID)
+    const recipe = recipeService_1.recipeService.getRecipeById(meal.id);
+    if (recipe) {
+        return recipe;
+    }
+    // Try to find by name (remove day prefix if present)
+    const cleanName = meal.name.replace(/^(Monday|Tuesday|Wednesday|Thursday|Friday|Saturday|Sunday) - /, '');
+    return recipeService_1.recipeService.searchRecipes(cleanName)[0];
+}
+exports.getRecipeForMeal = getRecipeForMeal;

package/dist/recipeService.d.ts

@@ -0,0 +1,28 @@
+import { Recipe, RecipeFilter } from './types/recipe';
+export { RecipeFilter };
+export declare class RecipeService {
+    private recipes;
+    private recipesBS;
+    private currentLocale;
+    constructor(locale?: string);
+    setLocale(locale: string): void;
+    private getCurrentRecipes;
+    getAllRecipes(): Recipe[];
+    getRecipeById(id: string): Recipe | undefined;
+    getRecipesByCategory(category: 'breakfast' | 'lunch' | 'dinner' | 'snack'): Recipe[];
+    filterRecipes(filter: RecipeFilter): Recipe[];
+    getRecipesByTags(tags: string[]): Recipe[];
+    getRecipesForHealthGoals(healthGoals: string[]): Recipe[];
+    getRecipesForDietaryRestrictions(restrictions: string[]): Recipe[];
+    getRandomRecipe(category?: 'breakfast' | 'lunch' | 'dinner' | 'snack'): Recipe;
+    getWeeklyRecipeSuggestions(healthGoals: string[], dietaryRestrictions: string[]): {
+        breakfast: Recipe[];
+        lunch: Recipe[];
+        dinner: Recipe[];
+        snack: Recipe[];
+    };
+    searchRecipes(query: string): Recipe[];
+    getTotalTime(recipe: Recipe): number;
+    getRecipesByTotalTime(maxMinutes: number): Recipe[];
+}
+export declare const recipeService: RecipeService;