@happychef/algorithm 1.0.4 → 1.1.1

package/getAvailableTimeblocks.js

@@ -30,9 +30,10 @@ function parseDateTimeInTimeZone(dateStr, timeStr, timeZone) {
  * @param {number} guests - The number of guests for the reservation.
  * @param {Array} blockedSlots - Optional array of blocked time slots to exclude.
  * @param {string|null} giftcard - Optional giftcard to filter times by meal.
+ * @param {boolean} isAdmin - Optional flag to bypass time restrictions for admin users.
  * @returns {Object} - Returns a pruned object of available time blocks or shifts, or an empty object if out of range.
  */
-function getAvailableTimeblocks(data, dateStr, reservations, guests, blockedSlots = [], giftcard = null) {
+function getAvailableTimeblocks(data, dateStr, reservations, guests, blockedSlots = [], giftcard = null, isAdmin = false) {
   // Get 'uurOpVoorhand' from general settings
   let uurOpVoorhand = 4;
   if (
@@ -74,8 +75,8 @@ function getAvailableTimeblocks(data, dateStr, reservations, guests, blockedSlot
     targetDate.toLocaleString('en-US', { timeZone: timeZone })
   );
 
-  // Check if targetDateInTimeZone is within dagenInToekomst
-  if (targetDateInTimeZone > maxAllowedDate) {
+  // Check if targetDateInTimeZone is within dagenInToekomst (skip for admin)
+  if (!isAdmin && targetDateInTimeZone > maxAllowedDate) {
     // Out of allowed range, return empty object
     return {};
   }
@@ -85,10 +86,10 @@ function getAvailableTimeblocks(data, dateStr, reservations, guests, blockedSlot
     currentTimeInTimeZone.toDateString() === targetDateInTimeZone.toDateString();
 
   // Get available time blocks or shifts
-  const availableTimeblocks = timeblocksAvailable(data, dateStr, reservations, guests, blockedSlots, giftcard);
+  const availableTimeblocks = timeblocksAvailable(data, dateStr, reservations, guests, blockedSlots, giftcard, isAdmin);
 
-  // If the date is today and uurOpVoorhand is greater than zero, prune time blocks
-  if (isToday && uurOpVoorhand >= 0) {
+  // If the date is today and uurOpVoorhand is greater than zero, prune time blocks (skip for admin)
+  if (!isAdmin && isToday && uurOpVoorhand >= 0) {
     const cutoffTime = new Date(currentTimeInTimeZone.getTime());
     cutoffTime.setHours(cutoffTime.getHours() + uurOpVoorhand);
 

package/index.js

@@ -3,16 +3,16 @@
 const processing = {
     ...require("./processing/dailyGuestCounts"),
     ...require("./processing/mealTypeCount"),
-    ...require("./processing/timeblocksAvailable"),
+    ...require("./processing/timeblocksAvailable")
 };
 
 const reservation_data = {
-    ...require("./reservation_data/counter"),
+    ...require("./reservation_data/counter")
 };
 
 const restaurant_data = {
     ...require("./restaurant_data/exceptions"),
-    ...require("./restaurant_data/openinghours"),
+    ...require("./restaurant_data/openinghours")
 };
 
 const test = {
@@ -24,39 +24,19 @@ const test = {
     ...require("./simulateTableAssignment"),
     ...require("./isDateAvailableWithTableCheck"),
     ...require("./tableHelpers"),
-    ...require("./test"),
+    ...require("./test")
 };
 
 const filters = {
     ...require("./filters/timeFilter"),
     ...require("./filters/maxArrivalsFilter"),
-    ...require("./filters/maxGroupsFilter"),
+    ...require("./filters/maxGroupsFilter")
 };
-
-// ✅ Table-related logic and utilities
-const tables = {
-    ...require("./tables/main.js"),
-    ...require("./tables/availability/isTimeAvailableSync"),
-    ...require("./tables/availability/getAvailableTablesForTime"),
-    ...require("./tables/availability/findMultiTableCombination"),
-    ...require("./tables/assignment/filterTimeblocksByTableAvailability"),
-    ...require("./tables/assignment/assignTablesForGivenTime"), 
-    ...require("./tables/utils/safeParseInt"),
-    ...require("./tables/utils/isTemporaryTableValid"),
-    ...require("./tables/utils/isTableFreeForAllSlots"),
-    ...require("./tables/utils/calculateDistance"),
-    ...require("./tables/time/shifts").shifts,
-    ...require("./tables/time/parseTime"),
-    ...require("./tables/time/getMealTypeByTime"),
-    ...require("./tables/time/computeRequiredSlots"),
-};
-
-// ✅ Export everything
+// Merge all exports into one
 module.exports = {
     ...processing,
     ...reservation_data,
     ...restaurant_data,
     ...test,
-    ...filters,
-    ...tables,
+    ...filters
 };

package/isDateAvailable.js

@@ -59,16 +59,17 @@ function isDateWithinAllowedRange(data, dateStr) {
  * @param {number} guests - The number of guests for the reservation.
  * @param {Array} blockedSlots - Optional array of blocked time slots to exclude.
  * @param {string|null} giftcard - Optional giftcard to filter times by meal.
+ * @param {boolean} isAdmin - Optional flag to bypass time restrictions for admin users.
  * @returns {boolean} - Returns true if the date has at least one available timeblock, false otherwise.
  */
-function isDateAvailable(data, dateStr, reservations, guests, blockedSlots = [], giftcard = null) {
-  // Check if date is within allowed range
-  if (!isDateWithinAllowedRange(data, dateStr)) {
+function isDateAvailable(data, dateStr, reservations, guests, blockedSlots = [], giftcard = null, isAdmin = false) {
+  // Check if date is within allowed range (skip for admin)
+  if (!isAdmin && !isDateWithinAllowedRange(data, dateStr)) {
     return false;
   }
 
   // Get available timeblocks using the existing logic
-  const availableTimeblocks = getAvailableTimeblocks(data, dateStr, reservations, guests, blockedSlots, giftcard);
+  const availableTimeblocks = getAvailableTimeblocks(data, dateStr, reservations, guests, blockedSlots, giftcard, isAdmin);
 
   // Return true only if we have at least one available timeblock
   return Object.keys(availableTimeblocks).length > 0;

package/isDateAvailableWithTableCheck.js

@@ -71,9 +71,10 @@ function timeHasGiftcard(data, dateStr, timeStr, giftcard) {
  * @param {number} guests - The number of guests for the reservation.
  * @param {Array} blockedSlots - Optional array of blocked time slots to exclude.
  * @param {string|null} selectedGiftcard - The selected giftcard (if any).
+ * @param {boolean} isAdmin - Optional flag to bypass time restrictions for admin users.
  * @returns {boolean} - Returns true if the date passes all checks to be available.
  */
-function isDateAvailableWithTableCheck(data, dateStr, reservations, guests, blockedSlots = [], selectedGiftcard = null) {
+function isDateAvailableWithTableCheck(data, dateStr, reservations, guests, blockedSlots = [], selectedGiftcard = null, isAdmin = false) {
   // 0) Optionally filter by selected menu item's date range (only when normalOpeningTimes = false)
   const currentItem = typeof window !== 'undefined' ? window.currentReservationTicketItem : null;
   if (
@@ -113,7 +114,7 @@ function isDateAvailableWithTableCheck(data, dateStr, reservations, guests, bloc
   console.log(`Table assignment is ${isTableAssignmentEnabled ? 'ENABLED' : 'DISABLED'} for date ${dateStr}`);
 
   // 1) First, do the standard day-level checks (including simple giftcard check).
-  const basicDateAvailable = isDateAvailable(data, dateStr, reservations, guests, blockedSlots, selectedGiftcard);
+  const basicDateAvailable = isDateAvailable(data, dateStr, reservations, guests, blockedSlots, selectedGiftcard, isAdmin);
   if (!basicDateAvailable) {
     console.log(`Date ${dateStr} fails basic availability check`);
     return false;
@@ -127,7 +128,7 @@ function isDateAvailableWithTableCheck(data, dateStr, reservations, guests, bloc
 
   // 2) Get all available timeblocks for this date
   console.log(`Getting available timeblocks for ${dateStr}`);
-  const availableTimeblocks = getAvailableTimeblocks(data, dateStr, reservations, guests, blockedSlots, selectedGiftcard);
+  const availableTimeblocks = getAvailableTimeblocks(data, dateStr, reservations, guests, blockedSlots, selectedGiftcard, isAdmin);
   console.log(`Found ${Object.keys(availableTimeblocks).length} available timeblocks before table check`);
 
   // If no timeblocks are available at all, exit early

package/isTimeAvailable.js

@@ -9,11 +9,12 @@ const { timeblocksAvailable } = require('./processing/timeblocksAvailable');
  * @param {number} guests - The number of guests for the new reservation request.
  * @param {Array} blockedSlots - Optional array of blocked time slots to exclude.
  * @param {string|null} giftcard - Optional giftcard to filter times by meal.
+ * @param {boolean} isAdmin - Optional flag to bypass time restrictions for admin users.
  * @returns {boolean} - Returns true if the time is available, false otherwise.
  */
-function isTimeAvailable(data, dateStr, timeStr, reservations, guests, blockedSlots = [], giftcard = null) {
+function isTimeAvailable(data, dateStr, timeStr, reservations, guests, blockedSlots = [], giftcard = null, isAdmin = false) {
   // Get all available timeblocks for the specified date and guest count
-  const availableTimeblocks = timeblocksAvailable(data, dateStr, reservations, guests, blockedSlots, giftcard);
+  const availableTimeblocks = timeblocksAvailable(data, dateStr, reservations, guests, blockedSlots, giftcard, isAdmin);
 
   // Check if the specific timeStr is one of the available keys
   return Object.prototype.hasOwnProperty.call(availableTimeblocks, timeStr);

package/package.json

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

package/processing/timeblocksAvailable.js

@@ -89,7 +89,7 @@ function fitsWithinMeal(data, dateStr, startTimeStr, duurReservatie) {
   return startTime >= mealStartTime && startTime + duurReservatie <= mealEndTime;
 }
 
-function timeblocksAvailable(data, dateStr, reservations, guests, blockedSlots = [], giftcard = null) {
+function timeblocksAvailable(data, dateStr, reservations, guests, blockedSlots = [], giftcard = null, isAdmin = false) {
   const duurReservatie = getDuurReservatie(data);
   const intervalReservatie = getInterval(data);
 
@@ -149,8 +149,8 @@ function timeblocksAvailable(data, dateStr, reservations, guests, blockedSlots =
     }
   }
 
-  // Filter out blocked time slots
-  if (blockedSlots && blockedSlots.length > 0) {
+  // Filter out blocked time slots (skip for admin)
+  if (!isAdmin && blockedSlots && blockedSlots.length > 0) {
     for (const blockedSlot of blockedSlots) {
       // Check if the blocked slot matches the current date
       if (blockedSlot.date === dateStr && blockedSlot.time) {

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) {

package/tables/assignment/assignTablesForGivenTime.js

@@ -1,79 +0,0 @@
-const safeParseInt = require('../utils/safeParseInt');
-const computeRequiredSlots = require('../time/computeRequiredSlots');
-const getAllTables = require('../data/getAllTables');
-const isTemporaryTableValid = require('../utils/isTemporaryTableValid');
-const findMultiTableCombination = require('../availability/findMultiTableCombination');
-const isTableFreeForAllSlots = require('../utils/isTableFreeForAllSlots');
-
-/**
- * Attempts to assign tables for a single reservation at a given time.
- * Returns an array of table numbers (single-table or multi-table).
- */
-function assignTablesForGivenTime(restaurantData, date, time, guests, tableOccupiedSlots, selectedZitplaats = null) {
-
-    // FIXED: More robust parsing of settings with detailed logging
-    const generalSettings = restaurantData["general-settings"] || {};
-
-    // Check what format the data is in
-    // Check for MongoDB format
-    if (typeof generalSettings.duurReservatie === 'object' && generalSettings.duurReservatie?.$numberInt) {
-    }
-    if (typeof generalSettings.intervalReservatie === 'object' && 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);
-
-    if (intervalReservatie <= 0) {
-        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}`);
-        return [];
-    }
-
-    // Fetch all tables
-    const allTables = getAllTables(restaurantData, selectedZitplaats);
-
-    // Try single-table assignment first
-    for (const t of allTables) {
-        if (!isTemporaryTableValid(t, date, time)) continue;
-
-        if (t.minCapacity <= guests &&
-            guests <= t.maxCapacity &&
-            isTableFreeForAllSlots(t.tableNumber, requiredSlots, tableOccupiedSlots))
-        {
-            return [t.tableNumber];
-        }
-    }
-
-    // Try multi-table assignment
-    const best = { minDistance: Infinity, tables: [], tableCount: Infinity };
-    findMultiTableCombination(
-        allTables,
-        guests,
-        0,
-        [],
-        best,
-        requiredSlots,
-        tableOccupiedSlots,
-        date,
-        time
-    );
-
-    if (best.tables.length > 0) {
-    } else {
-    }
-
-    return best.tables.map(t => t.tableNumber);
-}
-
-module.exports = assignTablesForGivenTime;

package/tables/assignment/filterTimeblocksByTableAvailability.js

@@ -1,48 +0,0 @@
-// Import directly to avoid circular dependency with tables/main.js
-const isTimeAvailableSync = require('../availability/isTimeAvailableSync');
-
-/**
- * Filters timeblocks based on availability for a given guest count and date.
- */
-function filterTimeblocksByTableAvailability(
-  restaurantData,
-  date,
-  timeblocks,
-  guests,
-  reservations,
-  selectedZitplaats = null
-) {
-  if (guests < 0) {
-    guests = 0; // Use a reasonable default
-  }
-
-  const tableSettings = restaurantData?.['table-settings'] || {};
-  const isTableAssignmentEnabled =
-    tableSettings.isInstalled === true &&
-    tableSettings.assignmentMode === 'automatic';
-
-  if (!isTableAssignmentEnabled) {
-    return timeblocks;
-  }
-
-  const filteredTimeblocks = {};
-  let availableCount = 0;
-  let unavailableCount = 0;
-
-  for (const time in timeblocks) {
-    if (isTimeAvailableSync(restaurantData, date, time, guests, reservations, selectedZitplaats)) {
-      filteredTimeblocks[time] = timeblocks[time];
-      availableCount++;
-    } else {
-      unavailableCount++;
-    }
-  }
-
-  if (availableCount > 0) {
-    // no-op, preserve original structure
-  }
-
-  return filteredTimeblocks;
-}
-
-module.exports = filterTimeblocksByTableAvailability;

package/tables/availability/findMultiTableCombination.js

@@ -1,100 +0,0 @@
-const isTemporaryTableValid = require('../utils/isTemporaryTableValid');
-const isTableFreeForAllSlots = require('../utils/isTableFreeForAllSlots');
-const calculateDistance = require('../utils/calculateDistance');
-
-/**
- * Backtracking function to find a combination of tables (multi-table assignment).
- */
-function findMultiTableCombination(
-    tables,
-    guestsNeeded,
-    startIndex,
-    currentSet,
-    best,
-    requiredSlots,
-    tableOccupiedSlots,
-    reservationDateStr,
-    reservationTimeStr
-) {
-    // Base case: All guests are seated
-    if (guestsNeeded <= 0) {
-        // Calculate total distance for the current combination
-        let distanceSum = 0;
-        for (let i = 0; i < currentSet.length; i++) {
-            for (let j = i + 1; j < currentSet.length; j++) {
-                distanceSum += calculateDistance(currentSet[i], currentSet[j]);
-            }
-        }
-        // Update best solution if this one is better (fewer tables, then lower distance)
-        if (currentSet.length < best.tableCount || (currentSet.length === best.tableCount && distanceSum < best.minDistance)) {
-            best.minDistance = distanceSum;
-            best.tables = [...currentSet]; // Store a copy
-            best.tableCount = currentSet.length;
-        }
-        return;
-    }
-
-    if (startIndex >= tables.length) {
-        return;
-    }
-
-    if (currentSet.length >= best.tableCount && best.tableCount !== Infinity) {
-        return; // Pruning based on table count
-    }
-
-    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)) 
-        {
-            maxPossibleCapacity += tbl.maxCapacity;
-        }
-    }
-
-    if (maxPossibleCapacity < guestsNeeded) {
-        return; // Impossible to seat remaining guests
-    }
-
-    for (let i = startIndex; i < tables.length; i++) {
-        const tbl = tables[i];
-
-        // 1. Check if temporary table is valid for this date/time
-        if (!isTemporaryTableValid(tbl, reservationDateStr, reservationTimeStr)) {
-            continue;
-        }
-
-        // 2. Check if table is free for all required slots
-        if (!isTableFreeForAllSlots(tbl.tableNumber, requiredSlots, tableOccupiedSlots)) {
-            continue;
-        }
-
-        // 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);
-
-        findMultiTableCombination(
-            tables,
-            guestsNeeded - canSeat,
-            i + 1,
-            currentSet,
-            best,
-            requiredSlots,
-            tableOccupiedSlots,
-            reservationDateStr,
-            reservationTimeStr
-        );
-
-        currentSet.pop(); // Backtrack
-    }
-}
-
-module.exports = findMultiTableCombination;