@happychef/algorithm 1.0.4 → 1.1.0

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.0",
   "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/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;

package/tables/availability/getAvailableTablesForTime.js

@@ -1,106 +0,0 @@
-const safeParseInt = require('../utils/safeParseInt');
-const computeRequiredSlots = require('../time/computeRequiredSlots');
-const getAllTables = require('../data/getAllTables');
-const isTemporaryTableValid = require('../utils/isTemporaryTableValid');
-const getActualTableAssignment = require('../data/getActualTableAssignment');
-const assignTablesForGivenTime = require('../assignment/assignTablesForGivenTime');
-
-/**
- * Returns array of available individual table objects for a specific time.
- */
-function getAvailableTablesForTime(restaurantData, date, time, guests, reservations, selectedZitplaats = null) {
-    try {
-        if (guests < 0) {
-            guests = 0;
-        }
-
-        const tableSettings = restaurantData?.['table-settings'] || {};
-        const isAutomaticAssignment = tableSettings.isInstalled === true &&
-                                       tableSettings.assignmentMode === "automatic";
-
-        if (!isAutomaticAssignment) {
-            return [];
-        }
-
-        if (!restaurantData?.floors || !Array.isArray(restaurantData.floors)) {
-            return [];
-        }
-        if (guests <= 0) return [];
-
-        const generalSettings = restaurantData["general-settings"] || {};
-        const duurReservatie = safeParseInt(generalSettings.duurReservatie, 120);
-        const intervalReservatie = safeParseInt(generalSettings.intervalReservatie, 15);
-
-        if (intervalReservatie <= 0) {
-             return [];
-        }
-
-        const requiredSlots = computeRequiredSlots(time, duurReservatie, intervalReservatie);
-        if (!requiredSlots || requiredSlots.length === 0) {
-            return [];
-        }
-
-        const tableOccupiedSlots = {};
-        const reservationsForDate = reservations
-            .filter(r => r.date === date && r.time && r.guests > 0)
-            .sort((a, b) => {
-                const timeA = a.time.split(':').map(Number);
-                const timeB = b.time.split(':').map(Number);
-                return (timeA[0] * 60 + timeA[1]) - (timeB[0] * 60 + timeB[1]);
-            });
-
-        for (const r of reservationsForDate) {
-            const actualTables = getActualTableAssignment(r);
-            let assignedTables = [];
-
-            if (actualTables.length > 0) {
-                assignedTables = actualTables;
-            } else {
-                assignedTables = assignTablesForGivenTime(restaurantData, r.date, r.time, r.guests, tableOccupiedSlots, null);
-            }
-
-            if (assignedTables.length > 0) {
-                const rSlots = computeRequiredSlots(r.time, duurReservatie, intervalReservatie);
-                if (!rSlots || rSlots.length === 0) continue;
-                assignedTables.forEach(tableNumber => {
-                    if (!tableOccupiedSlots[tableNumber]) {
-                        tableOccupiedSlots[tableNumber] = new Set();
-                    }
-                    rSlots.forEach(slot => tableOccupiedSlots[tableNumber].add(slot));
-                });
-            }
-        }
-
-        const allTables = getAllTables(restaurantData, selectedZitplaats);
-        const availableIndividualTables = [];
-
-        for (const t of allTables) {
-            if (!isTemporaryTableValid(t, date, time)) continue;
-            if (t.minCapacity <= guests && guests <= t.maxCapacity) {
-                if (tableOccupiedSlots && requiredSlots && !Array.isArray(requiredSlots)) {
-                    // (no-op guard, keeps logic consistent)
-                }
-                const isFree = (function(){
-                    const occupied = tableOccupiedSlots[t.tableNumber] || new Set();
-                    for (const s of requiredSlots) {
-                        if (occupied.has(s)) return false;
-                    }
-                    return true;
-                })();
-
-                if (isFree) {
-                    availableIndividualTables.push(t);
-                }
-            }
-        }
-
-        availableIndividualTables.sort((a, b) => a.tableNumber - b.tableNumber);
-
-        return availableIndividualTables;
-
-    } catch (error) {
-        return []; // Return empty on error
-    }
-}
-
-module.exports = getAvailableTablesForTime;

package/tables/availability/isTimeAvailableSync.js

@@ -1,128 +0,0 @@
-const safeParseInt = require('../utils/safeParseInt');
-const computeRequiredSlots = require('../time/computeRequiredSlots');
-const isTemporaryTableValid = require('../utils/isTemporaryTableValid');
-const getAllTables = require('../data/getAllTables');
-const getActualTableAssignment = require('../data/getActualTableAssignment');
-const assignTablesForGivenTime = require('../assignment/assignTablesForGivenTime');
-const isTableFreeForAllSlots = require('../utils/isTableFreeForAllSlots');
-const findMultiTableCombination = require('./findMultiTableCombination');
-
-/**
- * Synchronous availability check using table assignment simulation and/or actual assignments.
- */
-function isTimeAvailableSync(restaurantData, date, time, guests, reservations, selectedZitplaats = null) {
-
-    if (guests < 0) {
-        guests = 2; // Use a reasonable default
-    }
-
-    const tableSettings = restaurantData?.['table-settings'] || {};
-    const isTableAssignmentEnabled = tableSettings.isInstalled === true &&
-        tableSettings.assignmentMode === "automatic";
-
-    if (!isTableAssignmentEnabled) {
-        return true;
-    }
-
-    try {
-        // Basic data check
-        if (!restaurantData?.floors || !Array.isArray(restaurantData.floors)) {
-            console.error(`[isTimeAvailableSync] Missing floors data for ${date} ${time}`);
-            return false;
-        }
-
-        if (guests <= 0) {
-            console.error(`[isTimeAvailableSync] Invalid guest count: ${guests}`);
-            return false;
-        }
-
-        const generalSettings = restaurantData["general-settings"] || {};
-        let duurReservatie = 120;  // Default: 2 hours in minutes
-        let intervalReservatie = 15;  // Default: 15 minute intervals
-        duurReservatie = safeParseInt(generalSettings.duurReservatie, 120);
-        intervalReservatie = safeParseInt(generalSettings.intervalReservatie, 15);
-
-        if (intervalReservatie <= 0) {
-            console.error(`[isTimeAvailableSync] Invalid interval settings for ${date} ${time}`);
-            return false;
-        }
-
-        const requiredSlots = computeRequiredSlots(time, duurReservatie, intervalReservatie);
-        if (!requiredSlots || requiredSlots.length === 0) {
-            console.error(`[isTimeAvailableSync] Could not compute required slots for ${date} ${time}`);
-            return false;
-        }
-
-        // Build Occupancy Map using ACTUAL table assignments when available
-        const tableOccupiedSlots = {}; // { tableNumber: Set<slotMinutes> }
-        const reservationsForDate = reservations
-            .filter(r => r.date === date && r.time && r.guests > 0)
-            .sort((a, b) => {
-                const timeA = a.time.split(':').map(Number);
-                const timeB = b.time.split(':').map(Number);
-                return (timeA[0] * 60 + timeA[1]) - (timeB[0] * 60 + timeB[1]);
-            });
-
-        for (const r of reservationsForDate) {
-            // Try to get actual table assignment first
-            const actualTables = getActualTableAssignment(r);
-            let assignedTables = [];
-
-            if (actualTables.length > 0) {
-                assignedTables = actualTables;
-            } else {
-                // Fall back to simulation for backwards compatibility
-                assignedTables = assignTablesForGivenTime(restaurantData, r.date, r.time, r.guests, tableOccupiedSlots);
-            }
-
-            // Update the occupancy map based on the actual or simulated assignment
-            if (assignedTables.length > 0) {
-                const rSlots = computeRequiredSlots(r.time, duurReservatie, intervalReservatie);
-                if (!rSlots || rSlots.length === 0) continue;
-
-                assignedTables.forEach(tableNumber => {
-                    if (!tableOccupiedSlots[tableNumber]) {
-                        tableOccupiedSlots[tableNumber] = new Set();
-                    }
-                    rSlots.forEach(slot => tableOccupiedSlots[tableNumber].add(slot));
-                });
-            }
-        }
-
-        const allTables = getAllTables(restaurantData, selectedZitplaats);
-
-        // 1. Try single table assignment
-        for (const t of allTables) {
-            if (!isTemporaryTableValid(t, date, time)) continue;
-
-            if (t.minCapacity <= guests &&
-                guests <= t.maxCapacity &&
-                isTableFreeForAllSlots(t.tableNumber, requiredSlots, tableOccupiedSlots))
-            {
-                return true;
-            }
-        }
-
-        // 2. Try multi-table assignment
-        const best = { minDistance: Infinity, tables: [], tableCount: Infinity };
-        findMultiTableCombination(
-            allTables,
-            guests,
-            0, [], best,
-            requiredSlots,
-            tableOccupiedSlots,
-            date, time
-        );
-
-        const result = best.tables.length > 0;
-        if (result) {
-        } else {
-        }
-
-        return result;
-    } catch (error) {
-        return false; // Assume unavailable on error
-    }
-}
-
-module.exports = isTimeAvailableSync;