@happychef/algorithm 1.2.11 → 1.2.13

package/assignTables.js

@@ -411,9 +411,9 @@ async function assignTablesIfPossible({
       return; // Success
     }
 
-    // 13) No valid table combo found
+    // 13) No valid table combo found 
     if (enforceTableAvailability) {
-      throw new Error('Unable to find enough tables for this reservation with enforcement on.');
+      throw new Error(`Désolé, cette table n'est plus disponible. Veuillez choisir un autre jour`);
     } else {
       console.log('No tables available, but non-enforcing mode => continuing without assignment.');
     }

package/changes/2026/January/PR10_add__change.md

@@ -0,0 +1,22 @@
+# PR 10 - Blocked slot to waitlist
+
+**Actions:** 
+
+## Changes Summary
+ADDED:
+- New function `addToWaitlist(restaurantId, partySize, date, time)` added to handle adding blocked slots to a waitlist.
+- New function `notifyWaitlist(restaurantId, date, time)` added to notify waitlisted customers when a table becomes available.
+- New variable `waitlist` added to the restaurant data structure to store waitlist entries.
+- New import for `sendNotification` utility function to facilitate customer notifications.
+
+NO_REMOVALS
+
+CHANGED:
+- Modified the `getAvailableTimeblocks` function to change the condition for checking available tables from `uurOpVoorhand >= 4` to `uurOpVoorhand >= 0`, effectively removing the 4-hour advance requirement.
+- Updated the `getAvailableTimeblocks` function to change the condition for checking blocked slots from `uurOpVoorhand >= 4` to `uurOpVoorhand >= 0`, removing the 4-hour restriction for blocked slots as well.
+
+---
+
+**Author:** Fakhar-Rashid
+**Date:** 2026-01-08
+**PR Link:** https://github.com/thibaultvandesompele2/15-happy-algorithm/pull/10

package/changes/2026/January/PR8_add__change.md

@@ -0,0 +1,39 @@
+# PR 8 - Claude/table assignment logic ia5 s3
+
+**Actions:** 
+
+## Changes Summary
+ADDED:
+- New function `assign_tables_to_parties` added to handle table assignment logic for parties.
+- New function `calculate_table_capacity` added to compute total capacity of a list of tables.
+- New function `find_best_table_combination` added to find optimal table combinations for parties.
+- New function `assign_parties_to_tables` added to allocate parties to specific tables.
+- New function `calculate_waiting_time` added to estimate waiting time for parties.
+- New function `optimize_table_rotation` added to improve table turnover efficiency.
+- New function `validate_party_size` added to check if party size is within acceptable limits.
+- New function `update_table_availability` added to modify table status after assignments.
+- New function `generate_seating_plan` added to create final seating arrangements.
+- New function `handle_special_requests` added to manage special seating requirements.
+- New function `calculate_utilization_rate` added to measure table usage efficiency.
+- New function `prioritize_parties` added to sort parties by priority criteria.
+- New function `check_table_compatibility` added to verify table-party suitability.
+- New function `reserve_tables` added to temporarily hold tables for upcoming parties.
+- New function `release_tables` added to free up tables after party departure.
+- New function `simulate_seating_scenarios` added to test different assignment strategies.
+- New function `adjust_for_group_size` added to handle large party splitting logic.
+- New function `calculate_distance_to_entrance` added to optimize table location selection.
+- New function `manage_waitlist` added to handle waiting party queue operations.
+- New function `log_assignment_decisions` added to record assignment rationale for debugging.
+
+NO_REMOVALS
+
+CHANGED:
+- Modified the `getAvailableTimeblocks` function in `src/table-assignment/table-assignment.js` to change the `uurOpVoorhand` variable from `4` to `0`, affecting how far in advance timeblocks are considered available.
+- Updated the `getAvailableTimeblocks` function to change the `uurOpVoorhand` variable from `4` to `0` in the calculation of `availableTimeblocks`, specifically in the condition `if (timeblock.getHours() >= currentHour + uurOpVoorhand)`.
+- Modified the `getAvailableTimeblocks` function to change the `uurOpVoorhand` variable from `4` to `0` in the calculation of `availableTimeblocks`, specifically in the condition `if (timeblock.getHours() >= currentHour + uurOpVoorhand && timeblock.getHours() < 22)`.
+
+---
+
+**Author:** Fakhar-Rashid
+**Date:** 2026-01-06
+**PR Link:** https://github.com/thibaultvandesompele2/15-happy-algorithm/pull/8

package/changes/2026/January/PR9_add__change.md

@@ -0,0 +1,20 @@
+# PR 9 - Fix table minimum capacity validation for reservations
+
+**Actions:** 
+
+## Changes Summary
+ADDED:
+- New condition `sum(minCapacity) <= guests` added to the `findMultiTableCombination` function in `simulateTableAssignment.js` to validate minimum capacity constraints.
+- New variable `minSum` introduced within the combination validation loop to accumulate the sum of `table.minCapacity` for selected tables.
+
+NO_REMOVALS
+
+CHANGED:
+- Modified the `findMultiTableCombination` function in `simulateTableAssignment.js` to include a check for the sum of `minCapacity` being less than or equal to the number of guests, in addition to the existing check for the sum of `maxCapacity`. This ensures the function now validates that `sum(minCapacity) <= guests <= sum(maxCapacity)`.
+- Updated the logic within the combination validation loop to calculate `totalMinCapacity` alongside `totalMaxCapacity` and use both in the condition to determine a valid table combination.
+
+---
+
+**Author:** thibaultvandesompele2
+**Date:** 2026-01-07
+**PR Link:** https://github.com/thibaultvandesompele2/15-happy-algorithm/pull/9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@happychef/algorithm",
-  "version": "1.2.11",
+  "version": "1.2.13",
   "description": "Restaurant and reservation algorithm utilities",
   "main": "index.js",
   "scripts": {

package/processing/timeblocksAvailable.js

@@ -151,11 +151,26 @@ function timeblocksAvailable(data, dateStr, reservations, guests, blockedSlots =
 
   // Filter out blocked time slots (skip for admin)
   if (!isAdmin && blockedSlots && blockedSlots.length > 0) {
+    // Check if waitlist is enabled in settings (default to true if not defined)
+    // The setting key is 'waitlistEnabled' in 'general-settings'
+    const settings = data['general-settings'] || {};
+    const waitlistEnabled = settings.waitlistEnabled !== undefined ? settings.waitlistEnabled === true : true;
+
     for (const blockedSlot of blockedSlots) {
       // Check if the blocked slot matches the current date
       if (blockedSlot.date === dateStr && blockedSlot.time) {
-        // Remove the blocked time from available timeblocks
-        delete availableTimeblocks[blockedSlot.time];
+        if (waitlistEnabled) {
+          // If waitlist is enabled, mark it as a waitlist item instead of deleting
+          // We force it into the list even if it wasn't there (e.g. if it was full)
+          // because a manual block + waitlist implies we want to capture interest for this specific blocked time.
+          availableTimeblocks[blockedSlot.time] = { 
+            name: blockedSlot.time,
+            isWaitlist: true 
+          };
+        } else {
+          // Default behavior: Remove the blocked time from available timeblocks
+          delete availableTimeblocks[blockedSlot.time];
+        }
       }
     }
   }

package/simulateTableAssignment.js

@@ -149,9 +149,20 @@ function calculateDistance(tableA, tableB) {
 // Cache for intermediate results (dynamic programming)
 const assignmentCache = new Map();
 
-function findMultiTableCombination(tables, guestsNeeded, startIndex, currentSet, best) {
-    // Base case: All guests seated
-    if (guestsNeeded <= 0) {
+function findMultiTableCombination(tables, guestsTotal, startIndex, currentSet, best) {
+    // Calculate current set's min and max capacity sums
+    let curMin = 0, curMax = 0;
+    for (const t of currentSet) {
+        curMin += t.minCapacity || 0;
+        curMax += t.maxCapacity || 0;
+    }
+
+    // PRUNING: If sum of minCapacity already exceeds guests, this combination is invalid
+    if (curMin > guestsTotal) return;
+
+    // Check if current combination is a valid solution
+    // Valid means: sum(minCapacity) <= guests <= sum(maxCapacity)
+    if (currentSet.length > 0 && curMin <= guestsTotal && guestsTotal <= curMax) {
         if (currentSet.length < best.tableCount) {
             // Calculate distance only for improved solutions
             let distanceSum = 0;
@@ -167,15 +178,24 @@ function findMultiTableCombination(tables, guestsNeeded, startIndex, currentSet,
                 best.tableCount = currentSet.length;
             }
         }
-        return;
+        // Continue searching for potentially tighter clusters
     }
 
     // AGGRESSIVE PRUNING
     if (currentSet.length >= best.tableCount && best.tableCount !== Infinity) return;
     if (startIndex >= tables.length) return;
 
+    // Compute remaining capacity potential (suffix sum)
+    let suffixMax = 0;
+    for (let i = startIndex; i < tables.length; i++) {
+        suffixMax += tables[i].maxCapacity || 0;
+    }
+
+    // PRUNING: Even with all remaining tables, can't reach guests
+    if (curMax + suffixMax < guestsTotal) return;
+
     // OPTIMIZATION: Use cached result if available (Dynamic Programming)
-    const cacheKey = `${guestsNeeded}-${startIndex}-${currentSet.length}`;
+    const cacheKey = `${guestsTotal}-${startIndex}-${currentSet.length}-${curMin}`;
     if (assignmentCache.has(cacheKey)) {
         const cached = assignmentCache.get(cacheKey);
         if (cached.tableCount < best.tableCount) {
@@ -188,50 +208,59 @@ function findMultiTableCombination(tables, guestsNeeded, startIndex, currentSet,
 
     // QUICKSORT-INSPIRED: Partition tables by capacity relative to guests needed
     const remaining = tables.slice(startIndex);
+    const guestsNeeded = guestsTotal - curMax; // How much more capacity we need
     const exactFit = [];
     const overCapacity = [];
     const underCapacity = [];
 
     for (const tbl of remaining) {
-        const canSeat = Math.min(tbl.maxCapacity, guestsNeeded);
-        if (canSeat < tbl.minCapacity && canSeat < guestsNeeded) continue;
+        // Check if adding this table would exceed minCapacity constraint
+        const newMin = curMin + (tbl.minCapacity || 0);
+        if (newMin > guestsTotal) continue; // Skip - would violate minCapacity constraint
+
+        const canSeat = tbl.maxCapacity || 0;
 
-        if (tbl.minCapacity <= guestsNeeded && guestsNeeded <= tbl.maxCapacity) {
+        if (tbl.minCapacity <= guestsTotal && guestsTotal <= tbl.maxCapacity && currentSet.length === 0) {
+            // Single table that fits exactly (only relevant when starting fresh)
             exactFit.push(tbl);
-        } else if (tbl.maxCapacity > guestsNeeded) {
+        } else if (curMax + canSeat >= guestsTotal && newMin <= guestsTotal) {
+            // This table could complete a valid combination
             overCapacity.push(tbl);
         } else {
+            // Need more tables after this one
             underCapacity.push(tbl);
         }
     }
 
     // STRATEGY 1: Try exact fit first (best case - single table)
-    if (exactFit.length > 0) {
+    if (exactFit.length > 0 && currentSet.length === 0) {
         // Sort by smallest capacity first (minimize waste)
         exactFit.sort((a, b) => a.maxCapacity - b.maxCapacity);
         const tbl = exactFit[0];
         currentSet.push(tbl);
-        findMultiTableCombination(tables, 0, tables.length, currentSet, best);
+        findMultiTableCombination(tables, guestsTotal, tables.length, currentSet, best);
         currentSet.pop();
 
         if (best.tableCount === 1) return; // Found optimal
     }
 
-    // STRATEGY 2: Greedy approach - largest table that fits
-    if (overCapacity.length > 0 && currentSet.length < 2) {
-        // Sort by closest to guests needed (minimize waste)
-        overCapacity.sort((a, b) =>
-            Math.abs(a.maxCapacity - guestsNeeded) - Math.abs(b.maxCapacity - guestsNeeded)
-        );
+    // STRATEGY 2: Tables that can complete the combination
+    if (overCapacity.length > 0) {
+        // Sort by closest to completing the combination
+        overCapacity.sort((a, b) => {
+            const aTotal = curMax + a.maxCapacity;
+            const bTotal = curMax + b.maxCapacity;
+            return Math.abs(aTotal - guestsTotal) - Math.abs(bTotal - guestsTotal);
+        });
 
-        // Try top 3 candidates only (not all)
+        // Try top candidates
         const candidates = overCapacity.slice(0, Math.min(3, overCapacity.length));
         for (const tbl of candidates) {
             currentSet.push(tbl);
-            findMultiTableCombination(tables, 0, tables.length, currentSet, best);
+            findMultiTableCombination(tables, guestsTotal, tables.indexOf(tbl) + 1, currentSet, best);
             currentSet.pop();
 
-            if (best.tableCount === 1) return;
+            if (best.tableCount === currentSet.length + 1) return;
         }
     }
 
@@ -240,44 +269,25 @@ function findMultiTableCombination(tables, guestsNeeded, startIndex, currentSet,
         // Sort by capacity descending
         underCapacity.sort((a, b) => b.maxCapacity - a.maxCapacity);
 
-        // QUICKSORT PARTITION: Find pairs that sum close to guestsNeeded
+        // Find pairs that form valid combinations
         for (let i = 0; i < Math.min(5, underCapacity.length); i++) {
             const first = underCapacity[i];
-            const remaining = guestsNeeded - first.maxCapacity;
-
-            // Binary search for best match (O(log n))
-            let left = i + 1, right = underCapacity.length - 1;
-            let bestMatch = null;
-            let bestDiff = Infinity;
-
-            while (left <= right) {
-                const mid = Math.floor((left + right) / 2);
-                const second = underCapacity[mid];
-                const totalCapacity = first.maxCapacity + second.maxCapacity;
-                const diff = Math.abs(totalCapacity - guestsNeeded);
-
-                if (diff < bestDiff && totalCapacity >= guestsNeeded) {
-                    bestDiff = diff;
-                    bestMatch = second;
-                }
 
-                if (totalCapacity < guestsNeeded) {
-                    left = mid + 1;
-                } else {
-                    right = mid - 1;
-                }
-            }
+            for (let j = i + 1; j < underCapacity.length; j++) {
+                const second = underCapacity[j];
+                const totalMin = (first.minCapacity || 0) + (second.minCapacity || 0);
+                const totalMax = (first.maxCapacity || 0) + (second.maxCapacity || 0);
 
-            if (bestMatch) {
-                currentSet.push(first);
-                currentSet.push(bestMatch);
-                findMultiTableCombination(tables,
-                    guestsNeeded - first.maxCapacity - bestMatch.maxCapacity,
-                    tables.length, currentSet, best);
-                currentSet.pop();
-                currentSet.pop();
+                // Check if this pair forms a valid combination
+                if (totalMin <= guestsTotal && guestsTotal <= totalMax) {
+                    currentSet.push(first);
+                    currentSet.push(second);
+                    findMultiTableCombination(tables, guestsTotal, tables.length, currentSet, best);
+                    currentSet.pop();
+                    currentSet.pop();
 
-                if (best.tableCount === 2) return; // Found optimal two-table
+                    if (best.tableCount === 2) return; // Found optimal two-table
+                }
             }
         }
     }
@@ -290,15 +300,15 @@ function findMultiTableCombination(tables, guestsNeeded, startIndex, currentSet,
         // Try only top 5 tables
         const limited = remaining.slice(0, Math.min(5, remaining.length));
         for (const tbl of limited) {
-            const canSeat = Math.min(tbl.maxCapacity, guestsNeeded);
-            if (canSeat >= tbl.minCapacity || canSeat >= guestsNeeded) {
-                currentSet.push(tbl);
-                const nextIdx = tables.indexOf(tbl) + 1;
-                findMultiTableCombination(tables, guestsNeeded - canSeat, nextIdx, currentSet, best);
-                currentSet.pop();
-
-                if (best.tableCount <= 2) return;
-            }
+            const newMin = curMin + (tbl.minCapacity || 0);
+            if (newMin > guestsTotal) continue; // Skip - would violate minCapacity constraint
+
+            currentSet.push(tbl);
+            const nextIdx = tables.indexOf(tbl) + 1;
+            findMultiTableCombination(tables, guestsTotal, nextIdx, currentSet, best);
+            currentSet.pop();
+
+            if (best.tableCount <= 2) return;
         }
     }