healthy-meals-core 0.0.2

package/dist/recipeService.js

@@ -0,0 +1,136 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.recipeService = exports.RecipeService = void 0;
+const detailed_recipes_json_1 = __importDefault(require("../data/detailed-recipes.json"));
+const detailed_recipes_bs_json_1 = __importDefault(require("../data/detailed-recipes-bs.json"));
+class RecipeService {
+    constructor(locale = 'en') {
+        this.currentLocale = 'en';
+        this.recipes = detailed_recipes_json_1.default;
+        this.recipesBS = detailed_recipes_bs_json_1.default;
+        this.currentLocale = locale;
+    }
+    setLocale(locale) {
+        this.currentLocale = locale;
+    }
+    getCurrentRecipes() {
+        return this.currentLocale === 'bs' ? this.recipesBS : this.recipes;
+    }
+    getAllRecipes() {
+        return this.getCurrentRecipes();
+    }
+    getRecipeById(id) {
+        return this.getCurrentRecipes().find(recipe => recipe.id === id);
+    }
+    getRecipesByCategory(category) {
+        return this.getCurrentRecipes().filter(recipe => recipe.category === category);
+    }
+    filterRecipes(filter) {
+        return this.getCurrentRecipes().filter(recipe => {
+            if (filter.category && recipe.category !== filter.category) {
+                return false;
+            }
+            if (filter.tags && filter.tags.length > 0) {
+                const hasMatchingTag = filter.tags.some(tag => recipe.tags.includes(tag));
+                if (!hasMatchingTag) {
+                    return false;
+                }
+            }
+            if (filter.maxPrepTime && recipe.prepTime > filter.maxPrepTime) {
+                return false;
+            }
+            if (filter.maxCookTime && recipe.cookTime > filter.maxCookTime) {
+                return false;
+            }
+            if (filter.difficulty && recipe.difficulty !== filter.difficulty) {
+                return false;
+            }
+            if (filter.maxCalories && recipe.nutrition.calories > filter.maxCalories) {
+                return false;
+            }
+            if (filter.minProtein && recipe.nutrition.protein < filter.minProtein) {
+                return false;
+            }
+            return true;
+        });
+    }
+    getRecipesByTags(tags) {
+        return this.filterRecipes({ tags });
+    }
+    getRecipesForHealthGoals(healthGoals) {
+        const relevantTags = healthGoals.map(goal => {
+            switch (goal) {
+                case 'weight_loss':
+                    return ['low-carb', 'high-protein', 'low-fat'];
+                case 'muscle_gain':
+                    return ['high-protein'];
+                case 'heart_health':
+                    return ['heart-healthy', 'omega-3', 'cholesterol'];
+                case 'diabetes':
+                    return ['diabetes', 'low-carb'];
+                case 'cholesterol':
+                    return ['cholesterol', 'heart-healthy'];
+                case 'fatty_liver':
+                    return ['fatty_liver', 'low-fat'];
+                case 'triglycerides':
+                    return ['triglycerides', 'omega-3'];
+                default:
+                    return [];
+            }
+        }).flat();
+        return this.filterRecipes({ tags: relevantTags });
+    }
+    getRecipesForDietaryRestrictions(restrictions) {
+        return this.getCurrentRecipes().filter(recipe => {
+            if (restrictions.includes('vegetarian')) {
+                return recipe.tags.includes('vegetarian') || recipe.tags.includes('vegan');
+            }
+            if (restrictions.includes('vegan')) {
+                return recipe.tags.includes('vegan');
+            }
+            if (restrictions.includes('gluten-free')) {
+                return recipe.tags.includes('gluten-free');
+            }
+            return true;
+        });
+    }
+    getRandomRecipe(category) {
+        const filteredRecipes = category
+            ? this.getRecipesByCategory(category)
+            : this.getCurrentRecipes();
+        const randomIndex = Math.floor(Math.random() * filteredRecipes.length);
+        return filteredRecipes[randomIndex];
+    }
+    getWeeklyRecipeSuggestions(healthGoals, dietaryRestrictions) {
+        let availableRecipes = this.getCurrentRecipes();
+        if (dietaryRestrictions.length > 0) {
+            availableRecipes = this.getRecipesForDietaryRestrictions(dietaryRestrictions);
+        }
+        if (healthGoals.length > 0) {
+            const healthRecipes = this.getRecipesForHealthGoals(healthGoals);
+            availableRecipes = availableRecipes.filter(recipe => healthRecipes.some(hr => hr.id === recipe.id));
+        }
+        const breakfast = availableRecipes.filter(r => r.category === 'breakfast').slice(0, 7);
+        const lunch = availableRecipes.filter(r => r.category === 'lunch').slice(0, 7);
+        const dinner = availableRecipes.filter(r => r.category === 'dinner').slice(0, 7);
+        const snack = availableRecipes.filter(r => r.category === 'snack').slice(0, 7);
+        return { breakfast, lunch, dinner, snack };
+    }
+    searchRecipes(query) {
+        const lowerQuery = query.toLowerCase();
+        return this.getCurrentRecipes().filter(recipe => recipe.name.toLowerCase().includes(lowerQuery) ||
+            recipe.ingredients.some(ing => ing.name.toLowerCase().includes(lowerQuery)) ||
+            recipe.tags.some(tag => tag.toLowerCase().includes(lowerQuery)));
+    }
+    getTotalTime(recipe) {
+        return recipe.prepTime + recipe.cookTime;
+    }
+    getRecipesByTotalTime(maxMinutes) {
+        return this.recipes.filter(recipe => this.getTotalTime(recipe) <= maxMinutes);
+    }
+}
+exports.RecipeService = RecipeService;
+exports.recipeService = new RecipeService();

package/dist/rules/cholesterol.d.ts

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

package/dist/rules/cholesterol.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.filterCholesterol = void 0;
+function filterCholesterol(recipes) {
+    return recipes.filter(r => r.tags.includes('cholesterol'));
+}
+exports.filterCholesterol = filterCholesterol;

package/dist/rules/diabetes.d.ts

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

package/dist/rules/diabetes.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.filterDiabetes = void 0;
+function filterDiabetes(recipes) {
+    return recipes.filter(r => r.tags.includes('diabetes'));
+}
+exports.filterDiabetes = filterDiabetes;

package/dist/rules/fattyLiver.d.ts

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

package/dist/rules/fattyLiver.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.filterFattyLiver = void 0;
+function filterFattyLiver(recipes) {
+    return recipes.filter(r => r.tags.includes('fatty_liver'));
+}
+exports.filterFattyLiver = filterFattyLiver;

package/dist/rules/index.d.ts

@@ -0,0 +1,7 @@
+import { Recipe, HealthCondition } from '../types';
+export declare function applyHealthRules(recipes: Recipe[], conditions: HealthCondition[]): Recipe[];
+export * from './cholesterol';
+export * from './triglycerides';
+export * from './fattyLiver';
+export * from './diabetes';
+export * from './lowCarb';

package/dist/rules/index.js

@@ -0,0 +1,47 @@
+"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 });
+exports.applyHealthRules = void 0;
+const cholesterol_1 = require("./cholesterol");
+const triglycerides_1 = require("./triglycerides");
+const fattyLiver_1 = require("./fattyLiver");
+const diabetes_1 = require("./diabetes");
+const lowCarb_1 = require("./lowCarb");
+function applyHealthRules(recipes, conditions) {
+    let result = recipes;
+    if (conditions.includes('cholesterol')) {
+        result = (0, cholesterol_1.filterCholesterol)(result);
+    }
+    if (conditions.includes('triglycerides')) {
+        result = (0, triglycerides_1.filterTriglycerides)(result);
+    }
+    if (conditions.includes('fatty_liver')) {
+        result = (0, fattyLiver_1.filterFattyLiver)(result);
+    }
+    if (conditions.includes('diabetes')) {
+        result = (0, diabetes_1.filterDiabetes)(result);
+    }
+    if (conditions.includes('low_carb')) {
+        result = (0, lowCarb_1.filterLowCarb)(result);
+    }
+    return result;
+}
+exports.applyHealthRules = applyHealthRules;
+__exportStar(require("./cholesterol"), exports);
+__exportStar(require("./triglycerides"), exports);
+__exportStar(require("./fattyLiver"), exports);
+__exportStar(require("./diabetes"), exports);
+__exportStar(require("./lowCarb"), exports);

package/dist/rules/lowCarb.d.ts

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

package/dist/rules/lowCarb.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.filterLowCarb = void 0;
+function filterLowCarb(recipes) {
+    return recipes.filter(r => r.tags.includes('low_carb'));
+}
+exports.filterLowCarb = filterLowCarb;

package/dist/rules/triglycerides.d.ts

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

package/dist/rules/triglycerides.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.filterTriglycerides = void 0;
+function filterTriglycerides(recipes) {
+    return recipes.filter(r => r.tags.includes('triglycerides'));
+}
+exports.filterTriglycerides = filterTriglycerides;

package/dist/src/bmr.d.ts

@@ -0,0 +1,3 @@
+import { UserProfile } from './types';
+export declare function calculateBMR(profile: UserProfile): number;
+export declare function calculateTDEE(profile: UserProfile): number;

package/dist/src/bmr.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateBMR = calculateBMR;
+exports.calculateTDEE = calculateTDEE;
+function calculateBMR(profile) {
+    const { weightKg, heightCm, age, gender } = profile;
+    return gender === 'male'
+        ? 10 * weightKg + 6.25 * heightCm - 5 * age + 5
+        : 10 * weightKg + 6.25 * heightCm - 5 * age - 161;
+}
+function calculateTDEE(profile) {
+    return calculateBMR(profile) * profile.activityLevel;
+}

package/dist/src/dailyMealPlanGenerator.d.ts

@@ -0,0 +1,3 @@
+import { UserProfile } from './types/firestore';
+import { MealPlan } from './types/firestore';
+export declare function generateDailyMealPlan(profile: UserProfile, userId: string): MealPlan;

package/dist/src/dailyMealPlanGenerator.js

@@ -0,0 +1,210 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateDailyMealPlan = generateDailyMealPlan;
+const foodConversion_1 = require("./foodConversion");
+// Mock food data - in a real app, this would come from Open Food Facts search
+const mockFoods = {
+    // Breakfast foods
+    oatmeal: {
+        id: 'oatmeal',
+        name: 'Oatmeal',
+        brand: 'Generic',
+        nutritionPer100g: { calories: 379, protein: 13.2, carbs: 66.3, fat: 6.9 },
+        servingSize: 40,
+        unit: 'g'
+    },
+    banana: {
+        id: 'banana',
+        name: 'Banana',
+        brand: 'Generic',
+        nutritionPer100g: { calories: 89, protein: 1.1, carbs: 22.8, fat: 0.3 },
+        servingSize: 118,
+        unit: 'g'
+    },
+    milk: {
+        id: 'milk',
+        name: 'Whole Milk',
+        brand: 'Generic',
+        nutritionPer100g: { calories: 61, protein: 3.2, carbs: 4.8, fat: 3.3 },
+        servingSize: 244,
+        unit: 'ml'
+    },
+    // Lunch/Dinner proteins
+    chicken: {
+        id: 'chicken',
+        name: 'Chicken Breast',
+        brand: 'Generic',
+        nutritionPer100g: { calories: 165, protein: 31, carbs: 0, fat: 3.6 },
+        servingSize: 100,
+        unit: 'g'
+    },
+    salmon: {
+        id: 'salmon',
+        name: 'Salmon',
+        brand: 'Generic',
+        nutritionPer100g: { calories: 206, protein: 22, carbs: 0, fat: 13 },
+        servingSize: 100,
+        unit: 'g'
+    },
+    // Carbs
+    rice: {
+        id: 'rice',
+        name: 'White Rice',
+        brand: 'Generic',
+        nutritionPer100g: { calories: 130, protein: 2.7, carbs: 28, fat: 0.3 },
+        servingSize: 185,
+        unit: 'g'
+    },
+    bread: {
+        id: 'bread',
+        name: 'Whole Wheat Bread',
+        brand: 'Generic',
+        nutritionPer100g: { calories: 247, protein: 13, carbs: 41, fat: 3.5 },
+        servingSize: 45,
+        unit: 'g'
+    },
+    // Veggies
+    broccoli: {
+        id: 'broccoli',
+        name: 'Broccoli',
+        brand: 'Generic',
+        nutritionPer100g: { calories: 34, protein: 2.8, carbs: 7, fat: 0.4 },
+        servingSize: 91,
+        unit: 'g'
+    },
+    spinach: {
+        id: 'spinach',
+        name: 'Spinach',
+        brand: 'Generic',
+        nutritionPer100g: { calories: 23, protein: 2.9, carbs: 3.6, fat: 0.4 },
+        servingSize: 30,
+        unit: 'g'
+    },
+    // Snacks
+    apple: {
+        id: 'apple',
+        name: 'Apple',
+        brand: 'Generic',
+        nutritionPer100g: { calories: 52, protein: 0.3, carbs: 13.8, fat: 0.2 },
+        servingSize: 182,
+        unit: 'g'
+    },
+    almonds: {
+        id: 'almonds',
+        name: 'Almonds',
+        brand: 'Generic',
+        nutritionPer100g: { calories: 579, protein: 21.2, carbs: 21.6, fat: 49.9 },
+        servingSize: 28,
+        unit: 'g'
+    }
+};
+function calculateDailyNeeds(profile) {
+    // Provide defaults for missing profile data
+    const age = profile.age || 30;
+    const height = profile.height || 170; // cm
+    const weight = profile.weight || 70; // kg
+    const gender = profile.gender || 'male';
+    const activityLevel = profile.activityLevel || 'moderately_active';
+    // Basic BMR calculation (simplified)
+    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);
+    // Activity multiplier
+    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);
+    // Adjust based on goals
+    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)), // Minimum 1200 calories
+        protein: Math.round(Math.max(dailyCalories * 0.3 / 4, 50)), // Minimum 50g protein
+        carbs: Math.round(Math.max(dailyCalories * 0.4 / 4, 100)), // Minimum 100g carbs
+        fat: Math.round(Math.max(dailyCalories * 0.3 / 9, 30)) // Minimum 30g fat
+    };
+}
+function createMeal(name, type, foods) {
+    const ingredients = foods.map(({ food, amount, unit }) => (0, foodConversion_1.convertFoodItemToIngredient)(food, amount, unit));
+    const meal = (0, foodConversion_1.createMealFromFoodItems)(name, type, foods.map(({ food, amount, unit }, index) => ({
+        food: food,
+        amount,
+        unit
+    })));
+    return {
+        ...meal,
+        instructions: [`Prepare ${name} according to recipe`],
+    };
+}
+function generateDailyMealPlan(profile, userId) {
+    const needs = calculateDailyNeeds(profile);
+    // Check dietary restrictions
+    const isVegetarian = profile.dietaryRestrictions?.includes('vegetarian');
+    const isVegan = profile.dietaryRestrictions?.includes('vegan');
+    // Breakfast: Oatmeal with fruit
+    const breakfast = createMeal('Healthy Oatmeal Breakfast', 'breakfast', [
+        { food: mockFoods.oatmeal, amount: 50, unit: 'g' },
+        { food: mockFoods.banana, amount: 100, unit: 'g' },
+        { food: mockFoods.milk, amount: 200, unit: 'ml' }
+    ]);
+    // Lunch: Chicken salad (or vegetarian alternative)
+    const lunchProtein = isVegan ? mockFoods.broccoli : (isVegetarian ? mockFoods.broccoli : mockFoods.chicken);
+    const lunch = createMeal('Nutritious Lunch Salad', 'lunch', [
+        { food: lunchProtein, amount: lunchProtein === mockFoods.chicken ? 150 : 200, unit: 'g' },
+        { food: mockFoods.spinach, amount: 100, unit: 'g' },
+        { food: mockFoods.broccoli, amount: 150, unit: 'g' },
+        { food: mockFoods.bread, amount: 90, unit: 'g' }
+    ]);
+    // Dinner: Salmon with rice and veggies (or vegetarian alternative)
+    const dinnerProtein = isVegan ? mockFoods.broccoli : (isVegetarian ? mockFoods.broccoli : mockFoods.salmon);
+    const dinner = createMeal('Balanced Dinner', 'dinner', [
+        { food: dinnerProtein, amount: dinnerProtein === mockFoods.salmon ? 150 : 200, unit: 'g' },
+        { food: mockFoods.rice, amount: 150, unit: 'g' },
+        { food: mockFoods.broccoli, amount: 100, unit: 'g' }
+    ]);
+    // Snack: Apple and almonds
+    const snack = createMeal('Healthy Snack', 'snack', [
+        { food: mockFoods.apple, amount: 150, unit: 'g' },
+        { food: mockFoods.almonds, amount: 20, unit: 'g' }
+    ]);
+    const meals = [breakfast, lunch, dinner, snack];
+    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: total.carbs + (meal.nutrition?.carbs || 0),
+        fat: total.fat + (meal.nutrition?.fat || 0)
+    }), { calories: 0, protein: 0, carbs: 0, fat: 0 });
+    const today = new Date();
+    return {
+        id: `daily-plan-${Date.now()}`,
+        userId: userId,
+        name: `Daily Meal Plan - ${today.toLocaleDateString()}`,
+        description: `Personalized daily meal plan based on your profile (${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: Math.round(totalNutrition.calories),
+            proteinPercentage: 25,
+            carbsPercentage: 45,
+            fatPercentage: 30,
+        },
+        createdAt: new Date(),
+        updatedAt: new Date()
+    };
+}

package/dist/src/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[];