healthy-meals-core 0.0.2

package/dist/src/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/src/rules/cholesterol.d.ts

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

package/dist/src/rules/cholesterol.js

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

package/dist/src/rules/diabetes.d.ts

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

package/dist/src/rules/diabetes.js

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

package/dist/src/rules/fattyLiver.d.ts

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

package/dist/src/rules/fattyLiver.js

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

package/dist/src/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/src/rules/index.js

@@ -0,0 +1,46 @@
+"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 = applyHealthRules;
+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;
+}
+__exportStar(require("./cholesterol"), exports);
+__exportStar(require("./triglycerides"), exports);
+__exportStar(require("./fattyLiver"), exports);
+__exportStar(require("./diabetes"), exports);
+__exportStar(require("./lowCarb"), exports);

package/dist/src/rules/lowCarb.d.ts

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

package/dist/src/rules/lowCarb.js

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

package/dist/src/rules/triglycerides.d.ts

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

package/dist/src/rules/triglycerides.js

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

package/dist/src/types/firestore.d.ts

@@ -0,0 +1,100 @@
+export interface UserProfile {
+    uid: string;
+    email: string;
+    displayName?: string;
+    age: number;
+    gender: 'male' | 'female' | 'other';
+    height: number;
+    weight: number;
+    activityLevel: 'sedentary' | 'lightly_active' | 'moderately_active' | 'very_active' | 'extremely_active';
+    dietaryRestrictions: string[];
+    healthGoals: string[];
+    allergies: string[];
+    preferences: {
+        cuisineTypes: string[];
+        mealComplexity: 'simple' | 'moderate' | 'complex';
+        cookingTime: number;
+    };
+    createdAt: Date;
+    updatedAt: Date;
+}
+export interface Ingredient {
+    id: string;
+    name: string;
+    quantity: number;
+    unit: string;
+    calories: number;
+    protein: number;
+    carbs: number;
+    fat: number;
+    fiber: number;
+    sugar: number;
+    sodium: number;
+}
+export interface Meal {
+    id: string;
+    name: string;
+    type: 'breakfast' | 'lunch' | 'dinner' | 'snack';
+    ingredients: Ingredient[];
+    instructions: string[];
+    prepTime: number;
+    cookTime: number;
+    servings: number;
+    nutrition: {
+        calories: number;
+        protein: number;
+        carbs: number;
+        fat: number;
+        fiber: number;
+        sugar: number;
+        sodium: number;
+    };
+    tags: string[];
+    difficulty: 'easy' | 'medium' | 'hard';
+    createdAt: Date;
+    updatedAt: Date;
+}
+export interface DailyMealPlan {
+    id: string;
+    date: string;
+    meals: {
+        breakfast?: Meal;
+        lunch?: Meal;
+        dinner?: Meal;
+        snacks?: Meal[];
+    };
+    totalNutrition: {
+        calories: number;
+        protein: number;
+        carbs: number;
+        fat: number;
+        fiber: number;
+        sugar: number;
+        sodium: number;
+    };
+    createdAt: Date;
+    updatedAt: Date;
+}
+export interface MealPlan {
+    id: string;
+    userId: string;
+    name: string;
+    description?: string;
+    startDate: string;
+    endDate: string;
+    dailyPlans: DailyMealPlan[];
+    meals?: Meal[];
+    totalCalories?: number;
+    totalProtein?: number;
+    totalCarbs?: number;
+    totalFat?: number;
+    uid?: string;
+    goals: {
+        dailyCalories: number;
+        proteinPercentage: number;
+        carbsPercentage: number;
+        fatPercentage: number;
+    };
+    createdAt: Date;
+    updatedAt: Date;
+}

package/dist/src/types/firestore.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/types/openfoodfacts.d.ts

@@ -0,0 +1,113 @@
+export interface OpenFoodFactsProduct {
+    _id: string;
+    code: string;
+    product_name?: string;
+    product_name_en?: string;
+    brands?: string;
+    categories?: string;
+    labels?: string;
+    image_url?: string;
+    image_front_url?: string;
+    image_front_small_url?: string;
+    image_nutrition_url?: string;
+    image_nutrition_small_url?: string;
+    nutriments: Nutriments;
+    nutrition_grades?: string;
+    ecoscore_grade?: string;
+    nova_group?: number;
+    serving_size?: string;
+    serving_quantity?: number;
+    allergens?: string;
+    traces?: string;
+    ingredients_text?: string;
+    ingredients_text_en?: string;
+    countries?: string;
+    manufacturing_places?: string;
+    stores?: string;
+    packaging?: string;
+    quantity?: string;
+    completeness?: number;
+}
+export interface Nutriments {
+    energy?: number;
+    'energy-kcal'?: number;
+    'energy-kj'?: number;
+    'energy_100g'?: number;
+    'energy-kcal_100g'?: number;
+    'energy-kj_100g'?: number;
+    fat?: number;
+    fat_100g?: number;
+    'saturated-fat'?: number;
+    'saturated-fat_100g'?: number;
+    carbohydrates?: number;
+    carbohydrates_100g?: number;
+    sugars?: number;
+    sugars_100g?: number;
+    fiber?: number;
+    fiber_100g?: number;
+    proteins?: number;
+    proteins_100g?: number;
+    salt?: number;
+    salt_100g?: number;
+    sodium?: number;
+    sodium_100g?: number;
+    'nutrition-score-fr'?: number;
+    'nutrition-score-uk'?: number;
+}
+export interface OpenFoodFactsSearchResponse {
+    count: number;
+    page: number;
+    page_count: number;
+    page_size: number;
+    products: OpenFoodFactsProduct[];
+    skip: number;
+}
+export interface OpenFoodFactsProductResponse {
+    code: string;
+    product: OpenFoodFactsProduct;
+    status: number;
+    status_verbose: string;
+}
+export interface FoodSearchParams {
+    search_terms?: string;
+    categories?: string;
+    brands?: string;
+    countries?: string;
+    page?: number;
+    page_size?: number;
+    sort_by?: 'popularity' | 'product_name' | 'created_t' | 'last_modified_t';
+    fields?: string;
+}
+export interface NormalizedFoodItem {
+    id: string;
+    barcode: string;
+    name: string;
+    brand?: string;
+    imageUrl?: string;
+    nutritionPer100g: {
+        calories: number;
+        protein: number;
+        carbs: number;
+        fat: number;
+        fiber?: number;
+        sugar?: number;
+        sodium?: number;
+    };
+    nutritionGrade?: string;
+    ecoScore?: string;
+    novaGroup?: number;
+    servingSize?: string;
+    ingredients?: string;
+    allergens?: string[];
+    categories?: string[];
+}
+export interface FoodSearchFilters {
+    category?: string;
+    brand?: string;
+    nutritionGrade?: string;
+    ecoScore?: string;
+    novaGroup?: number;
+    minProtein?: number;
+    maxCalories?: number;
+    allergenFree?: string[];
+}

package/dist/src/types/openfoodfacts.js

@@ -0,0 +1,3 @@
+"use strict";
+// Open Food Facts API types and interfaces
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/types/recipe.d.ts

@@ -0,0 +1,36 @@
+export interface RecipeIngredient {
+    name: string;
+    quantity: number;
+    unit: string;
+}
+export interface RecipeNutrition {
+    calories: number;
+    protein: number;
+    carbs: number;
+    fat: number;
+    fiber: number;
+    sugar: number;
+    sodium: number;
+}
+export interface Recipe {
+    id: string;
+    name: string;
+    category: 'breakfast' | 'lunch' | 'dinner' | 'snack';
+    prepTime: number;
+    cookTime: number;
+    servings: number;
+    difficulty: 'easy' | 'medium' | 'hard';
+    ingredients: RecipeIngredient[];
+    instructions: string[];
+    nutrition: RecipeNutrition;
+    tags: string[];
+}
+export interface RecipeFilter {
+    category?: 'breakfast' | 'lunch' | 'dinner' | 'snack';
+    tags?: string[];
+    maxPrepTime?: number;
+    maxCookTime?: number;
+    difficulty?: 'easy' | 'medium' | 'hard';
+    maxCalories?: number;
+    minProtein?: number;
+}

package/dist/src/types/recipe.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/types.d.ts

@@ -0,0 +1,24 @@
+export type Gender = 'male' | 'female';
+export interface UserProfile {
+    heightCm: number;
+    weightKg: number;
+    age: number;
+    gender: Gender;
+    activityLevel: 1.2 | 1.375 | 1.55 | 1.725;
+    goals: 'maintain' | 'lose' | 'gain';
+    conditions: HealthCondition[];
+}
+export type HealthCondition = 'cholesterol' | 'triglycerides' | 'fatty_liver' | 'diabetes' | 'low_carb';
+export interface Recipe {
+    id: string;
+    name: string;
+    calories: number;
+    protein: number;
+    fat: number;
+    carbs: number;
+    tags: HealthCondition[];
+}
+export interface MealPlan {
+    dailyCalories: number;
+    meals: Recipe[];
+}

package/dist/src/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/variety.d.ts

@@ -0,0 +1,17 @@
+import { Recipe } from './types';
+export declare function shuffleArray<T>(array: T[]): T[];
+export declare function preventConsecutiveRepeats(meals: Recipe[]): Recipe[];
+export declare function ensureMealVariety(meals: Recipe[], minVariety?: number): Recipe[];
+export declare function calculateMealDiversity(meals: Recipe[]): number;
+export declare function getMealCategory(recipe: Recipe): string;
+export declare function calculateCategoryDiversity(meals: Recipe[]): number;
+export declare function hasConsecutiveRepeats(meals: Recipe[]): boolean;
+export declare function scoreMealPlan(meals: Recipe[]): {
+    diversity: number;
+    categoryDiversity: number;
+    proteinBalance: number;
+    calorieDistribution: number;
+    noConsecutiveRepeats: number;
+    overallScore: number;
+};
+export declare function selectDiverseMeals(availableRecipes: Recipe[], targetCalories: number, previousMeals?: Recipe[]): Recipe[];