@happychef/algorithm 1.1.0 → 1.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@happychef/algorithm",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "description": "Restaurant and reservation algorithm utilities",
   "main": "index.js",
   "author": "happy chef",

package/simulateTableAssignment.js

@@ -135,7 +135,11 @@ function calculateDistance(tableA, tableB) {
 }
 
 /**
- * Backtracking function to find a combination of tables (multi-table assignment).
+ * OPTIMIZED: Backtracking function to find a combination of tables (multi-table assignment).
+ * Improvements:
+ * - Pre-computed valid tables list to avoid redundant checks
+ * - Better pruning with capacity tracking
+ * - Early termination when exact match found
  */
 function findMultiTableCombination(tables, guestsNeeded, startIndex, currentSet, best, requiredSlots, tableOccupiedSlots, reservationDateStr, reservationTimeStr) {
     // Base case: All guests are seated
@@ -152,7 +156,7 @@ function findMultiTableCombination(tables, guestsNeeded, startIndex, currentSet,
             best.minDistance = distanceSum;
             best.tables = [...currentSet]; // Store a copy
             best.tableCount = currentSet.length;
-            console.log(`Found new best table combination: ${best.tables.map(t => t.tableNumber).join(', ')} for ${guestsNeeded} guests`);
+            console.log(`Found new best table combination: ${best.tables.map(t => t.tableNumber).join(', ')}`);
         }
         return;
     }
@@ -161,21 +165,23 @@ function findMultiTableCombination(tables, guestsNeeded, startIndex, currentSet,
         return;
     }
 
+    // OPTIMIZATION: Prune if we already have enough tables in current set
     if (currentSet.length >= best.tableCount && best.tableCount !== Infinity) {
-        return; // Pruning based on table count
+        return; // Can't improve on current best
     }
 
+    // OPTIMIZATION: Calculate max possible capacity from remaining tables
     let maxPossibleCapacity = 0;
     for (let i = startIndex; i < tables.length; i++) {
         const tbl = tables[i];
         // Only consider valid & free tables for potential capacity
         if (isTemporaryTableValid(tbl, reservationDateStr, reservationTimeStr) &&
-            isTableFreeForAllSlots(tbl.tableNumber, requiredSlots, tableOccupiedSlots)) 
+            isTableFreeForAllSlots(tbl.tableNumber, requiredSlots, tableOccupiedSlots))
         {
             maxPossibleCapacity += tbl.maxCapacity;
         }
     }
-    
+
     if (maxPossibleCapacity < guestsNeeded) {
         return; // Impossible to seat remaining guests
     }
@@ -188,24 +194,23 @@ function findMultiTableCombination(tables, guestsNeeded, startIndex, currentSet,
         if (!isTemporaryTableValid(tbl, reservationDateStr, reservationTimeStr)) {
             continue; // Skip invalid temporary table
         }
-        
+
         // 2. Check if table is free for all required slots
         if (!isTableFreeForAllSlots(tbl.tableNumber, requiredSlots, tableOccupiedSlots)) {
             continue; // Skip occupied table
         }
-        
+
         // 3. Check if table contributes meaningfully
         const canSeat = Math.min(tbl.maxCapacity, guestsNeeded);
         if (canSeat < tbl.minCapacity && canSeat < guestsNeeded) {
             continue; // Don't use a table for fewer than its min capacity unless it fulfills the remainder
         }
-        
+
         if (canSeat <= 0) continue; // Table doesn't help
 
         // --- Recurse ---
         currentSet.push(tbl); // Add table to current combination
-        console.log(`Trying table ${tbl.tableNumber} (${tbl.minCapacity}-${tbl.maxCapacity}) for ${canSeat}/${guestsNeeded} guests`);
-        
+
         findMultiTableCombination(
             tables,
             guestsNeeded - canSeat, // Reduce guests needed
@@ -217,35 +222,26 @@ function findMultiTableCombination(tables, guestsNeeded, startIndex, currentSet,
             reservationDateStr,
             reservationTimeStr
         );
-        
+
         currentSet.pop(); // Backtrack: remove table to explore other combinations
+
+        // OPTIMIZATION: Early exit if we found a single-table solution (best possible)
+        if (best.tableCount === 1) {
+            return;
+        }
     }
 }
 
 function assignTablesForGivenTime(restaurantData, date, time, guests, tableOccupiedSlots, selectedZitplaats = null) {
     console.log(`[assignTablesForGivenTime] Processing ${date} ${time} for ${guests} guests`);
-    
+
     // FIXED: More robust parsing of settings with detailed logging
     const generalSettings = restaurantData["general-settings"] || {};
-    console.log("[assignTablesForGivenTime] General settings:", generalSettings);
-    
-    // Check what format the data is in
-    console.log("[assignTablesForGivenTime] duurReservatie format:", typeof generalSettings.duurReservatie);
-    console.log("[assignTablesForGivenTime] intervalReservatie format:", typeof generalSettings.intervalReservatie);
-    
-    // Check for MongoDB format
-    if (typeof generalSettings.duurReservatie === 'object' && generalSettings.duurReservatie?.$numberInt) {
-        console.log("[assignTablesForGivenTime] duurReservatie is in MongoDB format:", generalSettings.duurReservatie?.$numberInt);
-    }
-    
-    if (typeof generalSettings.intervalReservatie === 'object' && generalSettings.intervalReservatie?.$numberInt) {
-        console.log("[assignTablesForGivenTime] intervalReservatie is in MongoDB format:", generalSettings.intervalReservatie?.$numberInt);
-    }
-    
+
     // DEFAULT VALUES - this approach mirrors the TypeScript implementation
     let duurReservatie = 120;  // Default: 2 hours in minutes
     let intervalReservatie = 15;  // Default: 15 minute intervals
-    
+
     // Use safeParseInt for robust parsing
     duurReservatie = safeParseInt(generalSettings.duurReservatie, 120);
     intervalReservatie = safeParseInt(generalSettings.intervalReservatie, 15);
@@ -256,7 +252,7 @@ function assignTablesForGivenTime(restaurantData, date, time, guests, tableOccup
         console.error("Invalid interval settings.");
         return [];
     }
-    
+
     const requiredSlots = computeRequiredSlots(time, duurReservatie, intervalReservatie);
     if (!requiredSlots || requiredSlots.length === 0) {
         console.error(`Could not compute required slots for ${time}`);
@@ -267,17 +263,33 @@ function assignTablesForGivenTime(restaurantData, date, time, guests, tableOccup
     const allTables = getAllTables(restaurantData, selectedZitplaats);
     console.log(`[assignTablesForGivenTime] Checking ${allTables.length} tables`);
 
+    // OPTIMIZATION: Pre-filter and sort tables for better performance
+    // Filter out invalid and occupied tables first
+    const validTables = allTables.filter(t =>
+        isTemporaryTableValid(t, date, time) &&
+        isTableFreeForAllSlots(t.tableNumber, requiredSlots, tableOccupiedSlots)
+    );
+
+    if (validTables.length === 0) {
+        console.log(`[assignTablesForGivenTime] No valid tables available`);
+        return [];
+    }
+
+    // OPTIMIZATION: Sort tables by capacity (prefer exact matches first)
+    // This helps find optimal solutions faster
+    validTables.sort((a, b) => {
+        // Prioritize tables that can seat exactly the number of guests
+        const aExact = (a.minCapacity <= guests && guests <= a.maxCapacity) ? 0 : 1;
+        const bExact = (b.minCapacity <= guests && guests <= b.maxCapacity) ? 0 : 1;
+        if (aExact !== bExact) return aExact - bExact;
+
+        // Then sort by capacity (smaller tables first to minimize waste)
+        return a.maxCapacity - b.maxCapacity;
+    });
+
     // --- Try single-table assignment first ---
-    for (const t of allTables) {
-        // Use imported validation function
-        if (!isTemporaryTableValid(t, date, time)) {
-            continue;
-        }
-        
-        if (t.minCapacity <= guests && 
-            guests <= t.maxCapacity && 
-            isTableFreeForAllSlots(t.tableNumber, requiredSlots, tableOccupiedSlots)) 
-        {
+    for (const t of validTables) {
+        if (t.minCapacity <= guests && guests <= t.maxCapacity) {
             console.log(`[assignTablesForGivenTime] Assigned single table ${t.tableNumber} for ${guests} guests`);
             return [t.tableNumber];
         }
@@ -288,7 +300,7 @@ function assignTablesForGivenTime(restaurantData, date, time, guests, tableOccup
     // --- Try multi-table assignment ---
     const best = { minDistance: Infinity, tables: [], tableCount: Infinity };
     findMultiTableCombination(
-        allTables,
+        validTables, // Use pre-filtered and sorted tables
         guests,
         0, // Start index
         [], // Initial empty set
@@ -409,14 +421,28 @@ function isTimeAvailableSync(restaurantData, date, time, guests, reservations, s
         const allTables = getAllTables(restaurantData, selectedZitplaats); // Get all tables
         console.log(`[isTimeAvailableSync] Checking ${allTables.length} tables for new reservation`);
 
-        // 1. Try single table assignment
-        for (const t of allTables) {
-            if (!isTemporaryTableValid(t, date, time)) continue; // Check temporary validity
+        // OPTIMIZATION: Pre-filter valid tables
+        const validTables = allTables.filter(t =>
+            isTemporaryTableValid(t, date, time) &&
+            isTableFreeForAllSlots(t.tableNumber, requiredSlots, tableOccupiedSlots)
+        );
+
+        if (validTables.length === 0) {
+            console.log(`[isTimeAvailableSync] No valid tables available`);
+            return false;
+        }
+
+        // OPTIMIZATION: Sort for faster exact matches
+        validTables.sort((a, b) => {
+            const aExact = (a.minCapacity <= guests && guests <= a.maxCapacity) ? 0 : 1;
+            const bExact = (b.minCapacity <= guests && guests <= b.maxCapacity) ? 0 : 1;
+            if (aExact !== bExact) return aExact - bExact;
+            return a.maxCapacity - b.maxCapacity;
+        });
 
-            if (t.minCapacity <= guests &&
-                guests <= t.maxCapacity &&
-                isTableFreeForAllSlots(t.tableNumber, requiredSlots, tableOccupiedSlots))
-            {
+        // 1. Try single table assignment
+        for (const t of validTables) {
+            if (t.minCapacity <= guests && guests <= t.maxCapacity) {
                 console.log(`[isTimeAvailableSync] Found single table ${t.tableNumber} for ${guests} guests at ${time}`);
                 return true; // Available
             }
@@ -427,7 +453,7 @@ function isTimeAvailableSync(restaurantData, date, time, guests, reservations, s
         // 2. Try multi-table assignment
         const best = { minDistance: Infinity, tables: [], tableCount: Infinity };
         findMultiTableCombination(
-            allTables,
+            validTables, // Use pre-filtered tables
             guests,
             0, [], best,
             requiredSlots,
@@ -441,7 +467,7 @@ function isTimeAvailableSync(restaurantData, date, time, guests, reservations, s
         } else {
             console.log(`[isTimeAvailableSync] No table combination available`);
         }
-        
+
         return result; // Available if a combination was found
 
     } catch (error) {