@happychef/algorithm 1.0.0 → 1.0.2

package/getAvailableTimeblocks.js

@@ -28,9 +28,10 @@ function parseDateTimeInTimeZone(dateStr, timeStr, timeZone) {
  * @param {string} dateStr - The date string in "YYYY-MM-DD" format.
  * @param {Array} reservations - An array of reservation objects.
  * @param {number} guests - The number of guests for the reservation.
+ * @param {Array} blockedSlots - Optional array of blocked time slots to exclude.
  * @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) {
+function getAvailableTimeblocks(data, dateStr, reservations, guests, blockedSlots = []) {
   // Get 'uurOpVoorhand' from general settings
   let uurOpVoorhand = 4;
   if (
@@ -83,7 +84,7 @@ function getAvailableTimeblocks(data, dateStr, reservations, guests) {
     currentTimeInTimeZone.toDateString() === targetDateInTimeZone.toDateString();
 
   // Get available time blocks or shifts
-  const availableTimeblocks = timeblocksAvailable(data, dateStr, reservations, guests);
+  const availableTimeblocks = timeblocksAvailable(data, dateStr, reservations, guests, blockedSlots);
 
   // If the date is today and uurOpVoorhand is greater than zero, prune time blocks
   if (isToday && uurOpVoorhand >= 0) {

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,24 +24,39 @@ 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"),
 };
-// Merge all exports into one
+
+// ✅ Export everything
 module.exports = {
     ...processing,
     ...reservation_data,
     ...restaurant_data,
     ...test,
     ...filters,
-    ...tables
+    ...tables,
 };

package/isDateAvailable.js

@@ -57,16 +57,17 @@ function isDateWithinAllowedRange(data, dateStr) {
  * @param {string} dateStr - The date string in "YYYY-MM-DD" format.
  * @param {Array} reservations - An array of reservation objects.
  * @param {number} guests - The number of guests for the reservation.
+ * @param {Array} blockedSlots - Optional array of blocked time slots to exclude.
  * @returns {boolean} - Returns true if the date has at least one available timeblock, false otherwise.
  */
-function isDateAvailable(data, dateStr, reservations, guests) {
+function isDateAvailable(data, dateStr, reservations, guests, blockedSlots = []) {
   // Check if date is within allowed range
   if (!isDateWithinAllowedRange(data, dateStr)) {
     return false;
   }
 
   // Get available timeblocks using the existing logic
-  const availableTimeblocks = getAvailableTimeblocks(data, dateStr, reservations, guests);
+  const availableTimeblocks = getAvailableTimeblocks(data, dateStr, reservations, guests, blockedSlots);
 
   // Return true only if we have at least one available timeblock
   return Object.keys(availableTimeblocks).length > 0;

package/isTimeAvailable.js

@@ -7,11 +7,12 @@ const { timeblocksAvailable } = require('./processing/timeblocksAvailable');
  * @param {string} timeStr - The time string in "HH:MM" format.
  * @param {Array} reservations - An array of existing reservation objects.
  * @param {number} guests - The number of guests for the new reservation request.
+ * @param {Array} blockedSlots - Optional array of blocked time slots to exclude.
  * @returns {boolean} - Returns true if the time is available, false otherwise.
  */
-function isTimeAvailable(data, dateStr, timeStr, reservations, guests) {
+function isTimeAvailable(data, dateStr, timeStr, reservations, guests, blockedSlots = []) {
   // Get all available timeblocks for the specified date and guest count
-  const availableTimeblocks = timeblocksAvailable(data, dateStr, reservations, guests);
+  const availableTimeblocks = timeblocksAvailable(data, dateStr, reservations, guests, blockedSlots);
 
   // 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.0",
+  "version": "1.0.2",
   "description": "Restaurant and reservation algorithm utilities",
   "main": "index.js",
   "author": "happy chef",

package/processing/timeblocksAvailable.js

@@ -58,7 +58,7 @@ function fitsWithinMeal(data, dateStr, startTimeStr, duurReservatie) {
   return startTime >= mealStartTime && startTime + duurReservatie <= mealEndTime;
 }
 
-function timeblocksAvailable(data, dateStr, reservations, guests) {
+function timeblocksAvailable(data, dateStr, reservations, guests, blockedSlots = []) {
   const duurReservatie = getDuurReservatie(data);
   const intervalReservatie = getInterval(data);
 
@@ -112,6 +112,17 @@ function timeblocksAvailable(data, dateStr, reservations, guests) {
     }
   }
 
+  // Filter out blocked time slots
+  if (blockedSlots && blockedSlots.length > 0) {
+    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];
+      }
+    }
+  }
+
   return availableTimeblocks;
 }
 

package/tables/assignment/assignTablesForGivenTime.js

@@ -0,0 +1,79 @@
+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

@@ -0,0 +1,48 @@
+// 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

@@ -0,0 +1,100 @@
+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

@@ -0,0 +1,106 @@
+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

@@ -0,0 +1,128 @@
+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;

package/tables/data/extractTableNumbers.js

@@ -0,0 +1,17 @@
+const safeParseInt = require('../utils/safeParseInt');
+
+/**
+ * Extracts actual table numbers from a reservation's tables array.
+ * Handles MongoDB $numberInt format.
+ */
+function extractTableNumbers(tablesArray) {
+    if (!Array.isArray(tablesArray)) {
+        return [];
+    }
+
+    return tablesArray
+        .map(table => safeParseInt(table, null))
+        .filter(tableNum => tableNum !== null);
+}
+
+module.exports = extractTableNumbers;

package/tables/data/getActualTableAssignment.js

@@ -0,0 +1,16 @@
+const extractTableNumbers = require('./extractTableNumbers');
+
+/**
+ * Gets actual table assignments from reservation data if available.
+ * @param {Object} reservation - The reservation object
+ * @returns {Array} Array of table numbers that are actually assigned, or empty array if no data
+ */
+function getActualTableAssignment(reservation) {
+    if (reservation.tables && Array.isArray(reservation.tables)) {
+        const tableNumbers = extractTableNumbers(reservation.tables);
+        return tableNumbers;
+    }
+    return [];
+}
+
+module.exports = getActualTableAssignment;

package/tables/data/getAllTables.js

@@ -0,0 +1,84 @@
+/**
+ * Extracts and processes table data from the restaurantData object.
+ * Includes temporary table properties, zitplaats filtering, and sorts tables.
+ * @param {Object} restaurantData - The main restaurant data object.
+ * @param {string} selectedZitplaats - Optional zitplaats value to filter tables by.
+ * @returns {Array} An array of processed table objects.
+ */
+function getAllTables(restaurantData, selectedZitplaats = null) {
+    let allTables = [];
+    if (restaurantData?.floors && Array.isArray(restaurantData.floors)) {
+        restaurantData.floors.forEach(floor => {
+            if (floor?.tables && Array.isArray(floor.tables)) {
+                floor.tables.forEach(tbl => {
+                    // Ensure table number, capacities, priority exist before parsing
+                    const tableNumberRaw = tbl.tableNumber?.$numberInt ?? tbl.tableNumber;
+                    const minCapacityRaw = tbl.minCapacity?.$numberInt ?? tbl.minCapacity;
+                    const maxCapacityRaw = tbl.maxCapacity?.$numberInt ?? tbl.maxCapacity;
+                    const priorityRaw = tbl.priority?.$numberInt ?? tbl.priority;
+                    const xRaw = tbl.x?.$numberInt ?? tbl.x;
+                    const yRaw = tbl.y?.$numberInt ?? tbl.y;
+
+                    // Skip tables that don't match the selected zitplaats (if one is selected)
+                    if (selectedZitplaats && selectedZitplaats.trim() !== '' && tbl.zitplaats !== selectedZitplaats) {
+                        return; // Skip this table
+                    }
+
+                    if (tbl.objectType === "Tafel" &&
+                        tableNumberRaw !== undefined &&
+                        minCapacityRaw !== undefined &&
+                        maxCapacityRaw !== undefined &&
+                        priorityRaw !== undefined &&
+                        xRaw !== undefined &&
+                        yRaw !== undefined)
+                    {
+                        allTables.push({
+                            tableId: tbl.id,
+                            tableNumber: parseInt(tableNumberRaw, 10),
+                            minCapacity: parseInt(minCapacityRaw, 10),
+                            maxCapacity: parseInt(maxCapacityRaw, 10),
+                            priority: parseInt(priorityRaw, 10),
+                            x: parseInt(xRaw, 10),
+                            y: parseInt(yRaw, 10),
+                            isTemporary: tbl.isTemporary === true, // Ensure boolean
+                            startDate: tbl.startDate || null, // Expects 'YYYY-MM-DD'
+                            endDate: tbl.endDate || null,     // Expects 'YYYY-MM-DD'
+                            application: tbl.application || null, // Expects 'breakfast', 'lunch', or 'dinner'
+                            zitplaats: tbl.zitplaats || null // Add zitplaats to the table object
+                        });
+                    } else if (tbl.objectType === "Tafel") {
+                        console.warn(`Skipping table due to missing essential properties: ${JSON.stringify(tbl)}`);
+                    }
+                });
+            }
+        });
+    } else {
+        console.warn("Restaurant data is missing 'floors' array.");
+    }
+
+    // Sort tables
+    allTables.sort((a, b) => {
+        if (a.maxCapacity !== b.maxCapacity) {
+            return a.maxCapacity - b.maxCapacity;
+        }
+        if (a.priority !== b.priority) {
+            // Assuming lower priority number means higher priority
+            return a.priority - b.priority;
+        }
+        return a.minCapacity - b.minCapacity;
+    });
+
+    // Filter out tables where parsing failed (resulted in NaN)
+    allTables = allTables.filter(t =>
+        !isNaN(t.tableNumber) &&
+        !isNaN(t.minCapacity) &&
+        !isNaN(t.maxCapacity) &&
+        !isNaN(t.priority) &&
+        !isNaN(t.x) &&
+        !isNaN(t.y)
+    );
+
+    return allTables;
+}
+
+module.exports = getAllTables;

package/tables/main.js

@@ -0,0 +1,33 @@
+// Central public API for all table logic (replaces simulateTableAssignment.js)
+
+// Import primitives directly from their files to avoid circular deps.
+const isTimeAvailableSync = require('./availability/isTimeAvailableSync');
+const getAvailableTablesForTime = require('./availability/getAvailableTablesForTime');
+const filterTimeblocksByTableAvailability = require('./assignment/filterTimeblocksByTableAvailability');
+
+// Keep backward compatibility: expose getAvailableTimeblocksWithTableCheck
+// as an alias of filterTimeblocksByTableAvailability so existing imports continue to work.
+const getAvailableTimeblocksWithTableCheck = (
+  restaurantData,
+  date,
+  timeblocks,
+  guests,
+  reservations,
+  selectedZitplaats = null
+) =>
+  filterTimeblocksByTableAvailability(
+    restaurantData,
+    date,
+    timeblocks,
+    guests,
+    reservations,
+    selectedZitplaats
+  );
+
+module.exports = {
+  isTimeAvailableSync,
+  filterTimeblocksByTableAvailability,
+  getAvailableTimeblocksWithTableCheck,
+  getAvailableTablesForTime,
+  // assignTablesForGivenTime
+};

package/tables/time/computeRequiredSlots.js

@@ -0,0 +1,27 @@
+/**
+ * Converts a reservation's start time and duration into discrete time slots (in minutes from midnight).
+ */
+function computeRequiredSlots(timeString, durationMinutes, intervalMinutes) {
+    const timePattern = /^([01]\d|2[0-3]):([0-5]\d)$/;
+    if (!timeString || !timePattern.test(timeString)) {
+        return [];
+    }
+
+    const [hour, minute] = timeString.split(":").map(Number);
+    const startMinutes = hour * 60 + minute;
+
+    if (intervalMinutes <= 0) {
+        return [startMinutes];
+    }
+
+    const slotCount = Math.ceil(durationMinutes / intervalMinutes);
+
+    const slots = [];
+    for (let i = 0; i < slotCount; i++) {
+        slots.push(startMinutes + i * intervalMinutes);
+    }
+
+    return slots;
+}
+
+module.exports = computeRequiredSlots;

package/tables/time/getMealTypeByTime.js

@@ -0,0 +1,26 @@
+const parseTime = require('./parseTime');
+const { shifts } = require('./shifts');
+
+/**
+ * Determines the meal type ('breakfast', 'lunch', 'dinner') for a given time string ("HH:MM").
+ * Returns null if the time doesn't fall into a defined shift.
+ */
+function getMealTypeByTime(timeStr) {
+    const time = parseTime(timeStr);
+    if (isNaN(time)) return null;
+
+    for (const [mealType, shift] of Object.entries(shifts)) {
+        const start = parseTime(shift.start);
+        const end = parseTime(shift.end);
+        // Handle potential errors from parseTime if shift definitions are invalid
+        if (isNaN(start) || isNaN(end)) continue;
+
+        // Check if time falls within the shift range [start, end)
+        if (time >= start && time < end) {
+            return mealType;
+        }
+    }
+    return null; // Return null if no matching shift is found
+}
+
+module.exports = getMealTypeByTime;

package/tables/time/parseTime.js

@@ -0,0 +1,19 @@
+// --- Time and Shift Helpers ---
+
+/**
+ * Parses a time string ("HH:MM") into minutes since midnight.
+ * Returns NaN if the format is invalid.
+ */
+function parseTime(timeStr) {
+    if (!timeStr || typeof timeStr !== 'string') return NaN;
+    const parts = timeStr.split(':');
+    if (parts.length !== 2) return NaN;
+    const hours = parseInt(parts[0], 10);
+    const minutes = parseInt(parts[1], 10);
+    if (isNaN(hours) || isNaN(minutes) || hours < 0 || hours > 23 || minutes < 0 || minutes > 59) {
+        return NaN;
+    }
+    return hours * 60 + minutes;
+}
+
+module.exports = parseTime;

package/tables/time/shifts.js

@@ -0,0 +1,7 @@
+const shifts = {
+    breakfast: { start: '07:00', end: '11:00' },
+    lunch: { start: '11:00', end: '16:00' },
+    dinner: { start: '16:00', end: '23:00' }, // Adjust end time if needed
+};
+
+module.exports = { shifts };

package/tables/utils/calculateDistance.js

@@ -0,0 +1,13 @@
+/**
+ * Calculates Euclidean distance between two tables (assuming x, y properties).
+ */
+function calculateDistance(tableA, tableB) {
+    if (tableA?.x === undefined || tableA?.y === undefined || tableB?.x === undefined || tableB?.y === undefined) {
+        return Infinity; // Cannot calculate distance if coordinates are missing
+    }
+    const dx = tableA.x - tableB.x;
+    const dy = tableA.y - tableB.y;
+    return Math.sqrt(dx * dx + dy * dy);
+}
+
+module.exports = calculateDistance;

package/tables/utils/isTableFreeForAllSlots.js

@@ -0,0 +1,14 @@
+/**
+ * Checks if the given tableNumber is free for all requiredSlots based on the occupied map.
+ */
+function isTableFreeForAllSlots(tableNumber, requiredSlots, tableOccupiedSlots) {
+    const occupiedSlots = tableOccupiedSlots[tableNumber] || new Set();
+    for (const slot of requiredSlots) {
+        if (occupiedSlots.has(slot)) {
+            return false;
+        }
+    }
+    return true;
+}
+
+module.exports = isTableFreeForAllSlots;

package/tables/utils/isTemporaryTableValid.js

@@ -0,0 +1,39 @@
+const getMealTypeByTime = require('../time/getMealTypeByTime');
+
+/**
+ * Checks if a temporary table is valid for a specific reservation date and time.
+ * @param {Object} table - The table object (must include isTemporary, startDate, endDate, application).
+ * @param {string} reservationDateStr - The date of the reservation ("YYYY-MM-DD").
+ * @param {string} reservationTimeStr - The time of the reservation ("HH:MM").
+ * @returns {boolean} True if the table is valid, false otherwise.
+ */
+function isTemporaryTableValid(table, reservationDateStr, reservationTimeStr) {
+    if (!table.isTemporary) {
+        return true; // Not temporary, always valid (subject to other checks like availability)
+    }
+
+    // Check date range
+    if (!table.startDate || !table.endDate) {
+        return false; // Invalid temporary table definition
+    }
+    // Basic date string comparison (YYYY-MM-DD format)
+    if (reservationDateStr < table.startDate || reservationDateStr > table.endDate) {
+        // console.log(`Temporary Table ${table.tableNumber} skipped: Date ${reservationDateStr} outside range ${table.startDate}-${table.endDate}.`); // Optional verbose logging
+        return false;
+    }
+
+    // Check application (meal type/shift)
+    const reservationMealType = getMealTypeByTime(reservationTimeStr);
+    if (!reservationMealType) {
+        return false; // Cannot determine meal type for the reservation
+    }
+    if (table.application !== reservationMealType) {
+        // console.log(`Temporary Table ${table.tableNumber} skipped: Application '${table.application}' does not match reservation meal type '${reservationMealType}'.`); // Optional verbose logging
+        return false;
+    }
+
+    // console.log(`Temporary Table ${table.tableNumber} is valid for ${reservationDateStr} at ${reservationTimeStr} (${reservationMealType}).`); // Optional verbose logging
+    return true;
+}
+
+module.exports = isTemporaryTableValid;

package/tables/utils/safeParseInt.js

@@ -0,0 +1,29 @@
+/**
+ * Robust helper for parsing numeric values from various formats.
+ * Handles MongoDB $numberInt format and regular values.
+ */
+function safeParseInt(val, defaultValue) {
+    if (val === undefined || val === null) return defaultValue;
+
+    if (typeof val === 'object' && val !== null && '$numberInt' in val) {
+        try {
+            const parsed = parseInt(val.$numberInt, 10);
+            if (!isNaN(parsed)) return parsed;
+        } catch (e) {}
+        return defaultValue;
+    }
+
+    if (typeof val === 'number' && !isNaN(val)) {
+        return val;
+    }
+
+    if (typeof val === 'string') {
+        try {
+            const parsed = parseInt(val, 10);
+            if (!isNaN(parsed)) return parsed;
+        } catch (e) {}
+    }
+    return defaultValue;
+}
+
+module.exports = safeParseInt;