@happychef/algorithm 1.0.4 → 1.1.1

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;

package/tables/data/extractTableNumbers.js

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

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

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

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

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

@@ -1,26 +0,0 @@
-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/utils/safeParseInt.js

@@ -1,29 +0,0 @@
-/**
- * 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;