@happychef/algorithm 1.0.0

package/filters/maxGroupsFilter.js

@@ -0,0 +1,222 @@
+// src/Pages/NewReservation/StepOne/algorithm/filters/maxGroupsFilter.js
+// Import the dedicated getMealType function instead of relying on the openinghours version
+// This ensures consistency in meal type determination
+
+/**
+ * Determines the meal type (breakfast, lunch, dinner) based on the time.
+ * @param {string} time - Time in HH:MM format
+ * @returns {string|null} - Meal type or null if outside meal times
+ */
+function getMealType(time) {
+	const hour = parseInt(time.split(':')[0], 10);
+	
+	if (hour >= 4 && hour < 11) return 'breakfast';
+	if (hour >= 11 && hour < 16) return 'lunch';
+	if (hour >= 16 && hour < 23) return 'dinner';
+	
+	return null;
+  }
+  
+  // --- Add console logs for debugging ---
+  // Set DEBUG_MAX_GROUPS to true in your development environment to enable detailed logs
+  const DEBUG_MAX_GROUPS = true; // Set to true to enable detailed logs for this filter
+  
+  /**
+   * Helper function for conditional logging.
+   * @param {string} message - The log message.
+   * @param  {...any} args - Additional arguments to log.
+   */
+  function logDebug(message, ...args) {
+	if (DEBUG_MAX_GROUPS) {
+	  // Using console.debug might allow filtering in browser dev tools,
+	  // but console.log ensures visibility.
+	  console.log(`[MaxGroupsFilter] ${message}`, ...args);
+	}
+  }
+  // --- End log setup ---
+  
+  /**
+   * Extracts a number value from various data formats (e.g., MongoDB NumberInt).
+   * Handles null, undefined, object with $numberInt, number, and string representations.
+   * Returns null if the value is not a valid integer representation.
+   * @param {*} value - Value from data object.
+   * @returns {number|null} - Parsed integer or null if invalid.
+   */
+  function extractNumber(value) {
+	if (value === null || value === undefined) {
+	  return null;
+	}
+  
+	// Handle MongoDB NumberInt format: { "$numberInt": "1" }
+	if (typeof value === 'object' && value !== null && '$numberInt' in value) {
+	  const parsed = parseInt(value.$numberInt, 10);
+	  return isNaN(parsed) ? null : parsed;
+	}
+  
+	// Handle regular number type
+	if (typeof value === 'number') {
+	  // Ensure it's an integer, not float/Infinity/NaN
+	  return Number.isInteger(value) ? value : null;
+	}
+  
+	// Handle string number: "1"
+	if (typeof value === 'string') {
+	  const parsed = parseInt(value, 10);
+	  // Ensure the string was fully parsed as a number and is finite
+	  return isNaN(parsed) ? null : parsed;
+	}
+  
+	// Not a recognized number format
+	return null;
+  }
+  
+  /**
+   * Filters available timeblocks based on maximum group size limits for each meal period.
+   * It checks if adding a new reservation of 'guests' count would exceed the configured
+   * maximum number of groups allowed for various size thresholds within the specific meal period.
+   *
+   * @param {Object} restaurantData - The main restaurant data object, expected to contain keys like 'max-groups-breakfast', 'max-groups-lunch', etc.
+   * @param {string} dateStr - The date string in "YYYY-MM-DD" format.
+   * @param {Object} timeblocks - An object of available timeblocks { "HH:MM": timeData } that have passed previous filters.
+   * @param {Array} reservations - An array of existing reservation objects for potentially multiple dates.
+   * @param {number|string} guests - The number of guests for the new reservation being considered.
+   * @returns {Object} - A new object containing only the timeblocks that satisfy the max group limits.
+   */
+  function filterTimeblocksByMaxGroups(restaurantData, dateStr, timeblocks, reservations, guests) {
+	logDebug(`--- Running MaxGroupsFilter for Date: ${dateStr}, Guests: ${guests} ---`);
+	// Log the top-level keys related to max-groups to see what's actually present
+	const groupKeys = Object.keys(restaurantData).filter(k => k.startsWith('max-groups-'));
+	logDebug("Received restaurantData max-group keys:", groupKeys.length > 0 ? groupKeys : 'None found');
+  
+	const filteredBlocks = {}; // Initialize the object to store timeblocks that pass the filter
+	const guestsNumber = parseInt(guests, 10); // Ensure guest count is a number
+  
+	// Validate guest input
+	if (isNaN(guestsNumber) || guestsNumber <= 0) {
+	  logDebug(`Invalid guest count (${guests}). Returning all ${Object.keys(timeblocks).length} input blocks unfiltered.`);
+	  return timeblocks; // Return original blocks if guest count is invalid
+	}
+  
+	// Pre-filter reservations to only those on the specific date for efficiency
+	const reservationsOnDate = reservations.filter(r => r.date === dateStr);
+	logDebug(`Relevant reservations on ${dateStr}: ${reservationsOnDate.length}`);
+	logDebug(`Input timeblocks count: ${Object.keys(timeblocks).length}`);
+  
+	// Group reservations by meal type using our consistent getMealType function
+	const reservationsByMealType = {};
+	reservationsOnDate.forEach(r => {
+	  const mealType = getMealType(r.time);
+	  if (!mealType) return; // Skip if no meal type determined
+	  
+	  if (!reservationsByMealType[mealType]) {
+		reservationsByMealType[mealType] = [];
+	  }
+	  reservationsByMealType[mealType].push(r);
+	});
+	
+	logDebug('Reservations grouped by meal type:', reservationsByMealType);
+  
+	// Iterate through each timeblock that needs checking
+	for (const [time, timeData] of Object.entries(timeblocks)) {
+	  const mealType = getMealType(time); // Determine meal period (e.g., 'breakfast') using our consistent function
+	  logDebug(`\nChecking Time: ${time} -> Determined Meal: ${mealType}`);
+  
+	  // If the time doesn't fall into a recognized meal period, the filter doesn't apply
+	  if (!mealType) {
+		logDebug(`  Time ${time} has no associated meal type. Keeping block.`);
+		filteredBlocks[time] = timeData;
+		continue;
+	  }
+  
+	  // Construct the key for the settings specific to this meal (e.g., 'max-groups-breakfast')
+	  const maxGroupSettingsKey = `max-groups-${mealType}`;
+	  // Retrieve the settings object for this meal from the restaurant data
+	  const maxGroupSettings = restaurantData[maxGroupSettingsKey];
+  
+	  logDebug(`  Looking for settings using key: "${maxGroupSettingsKey}"`);
+	  // If no settings object exists for this meal type, the filter doesn't apply to this timeblock
+	  if (!maxGroupSettings || typeof maxGroupSettings !== 'object') {
+		logDebug(`  No settings found for key "${maxGroupSettingsKey}". Filter doesn't apply. Keeping block.`);
+		filteredBlocks[time] = timeData;
+		continue; // Move to the next timeblock
+	  }
+	  // Log the actual settings found for this meal to verify correctness
+	  logDebug(`  Found settings for ${mealType}:`, JSON.stringify(maxGroupSettings));
+  
+	  // --- Settings exist, now apply the filter logic ---
+	  let isTimeAllowed = true; // Assume the timeblock is allowed until a limit is violated
+  
+	  // Extract and sort the numeric group size limits defined in the settings (e.g., "6", "7" -> [6, 7])
+	  const limitSizes = Object.keys(maxGroupSettings)
+							 .map(key => parseInt(key, 10)) // Convert keys to numbers
+							 .filter(num => !isNaN(num) && num > 0) // Keep only positive integers
+							 .sort((a, b) => a - b); // Sort numerically (e.g., check 6 before 7)
+	  logDebug(`  Defined numeric limit sizes to check for ${mealType}: [${limitSizes.join(', ')}]`);
+  
+	  // Check against each defined limit size threshold
+	  for (const limitSize of limitSizes) {
+		const limitSizeStr = String(limitSize); // Original string key (e.g., "6")
+		logDebug(`    Checking Limit Condition: Groups of size >= ${limitSize}`);
+  
+		// Does the new booking we're considering (guestsNumber) meet or exceed this limit threshold?
+		// Example: If limitSize is 6, and guestsNumber is 7, this limit applies. If guestsNumber is 5, it doesn't.
+		if (guestsNumber >= limitSize) {
+		  logDebug(`      Applicable: Booking guests (${guestsNumber}) >= Limit threshold (${limitSize})`);
+  
+		  // Extract the maximum number of groups allowed for this threshold
+		  const maxAllowedCount = extractNumber(maxGroupSettings[limitSizeStr]);
+		  logDebug(`      Max groups allowed for >=${limitSize} is: ${maxAllowedCount} (raw setting: ${JSON.stringify(maxGroupSettings[limitSizeStr])})`);
+  
+		  // If the setting for this limit size is invalid (null or negative), treat it as 'no limit'
+		  if (maxAllowedCount === null || maxAllowedCount < 0) {
+			logDebug(`      Skipping check: Invalid or non-positive max count defined for size ${limitSize}.`);
+			continue; // Skip to the next limitSize
+		  }
+  
+		  // Get reservations for this meal type - using only reservations from the same meal type
+		  const reservationsForMealType = reservationsByMealType[mealType] || [];
+		  
+		  // Count how many existing reservations for this meal type meet or exceed this limit size
+		  const existingMatchingGroupsCount = reservationsForMealType.filter(reservation => {
+			const reservationGuests = parseInt(reservation.guests, 10);
+			return !isNaN(reservationGuests) && reservationGuests >= limitSize;
+		  }).length;
+		  
+		  logDebug(`      Count of existing groups >=${limitSize} found in ${mealType}: ${existingMatchingGroupsCount}`);
+  
+		  // THE CORE LOGIC: Check if adding the new group would exceed the max allowed count
+		  if (existingMatchingGroupsCount + 1 > maxAllowedCount) {
+			logDebug(`      *** VIOLATION DETECTED *** for limit >=${limitSize}.`);
+			logDebug(`      (Existing Groups: ${existingMatchingGroupsCount} + New Group: 1 = ${existingMatchingGroupsCount + 1}, which is > Max Allowed: ${maxAllowedCount})`);
+			logDebug(`      Blocking time ${time} due to this violation.`);
+			isTimeAllowed = false; // Mark the timeblock as blocked
+			break; // No need to check further limits for this timeblock; it has already failed.
+		  } else {
+			// This specific limit check passed
+			logDebug(`      OK: Limit for >=${limitSize} not exceeded. (Existing: ${existingMatchingGroupsCount} + New: 1 <= Max: ${maxAllowedCount})`);
+		  }
+		} else {
+		  // The new booking's guest count is smaller than the current limit threshold, so this rule doesn't restrict it.
+		  logDebug(`      Not Applicable: Booking guests (${guestsNumber}) < Limit threshold (${limitSize}). Skipping this check.`);
+		}
+	  } // End of loop through different limitSizes (e.g., checking 6, then 7)
+  
+	  // After checking all applicable limits for the timeblock:
+	  if (isTimeAllowed) {
+		logDebug(`  ✅ Result for time ${time}: ALLOWED (passed all applicable checks)`);
+		filteredBlocks[time] = timeData; // Add it to the results
+	  } else {
+		  logDebug(`  ❌ Result for time ${time}: BLOCKED (failed at least one limit check)`);
+		  // Do not add it to filteredBlocks
+	  }
+	} // End of loop through all input timeblocks
+  
+	logDebug(`--- MaxGroupsFilter Finished. Output timeblocks count: ${Object.keys(filteredBlocks).length} ---`);
+	return filteredBlocks; // Return the timeblocks that passed all checks
+  }
+  
+  // Export the function for use in other parts of the application
+  module.exports = {
+	filterTimeblocksByMaxGroups,
+	getMealType, // Export getMealType for potential use by other modules
+  };

package/filters/timeFilter.js

@@ -0,0 +1,90 @@
+// Archief/Fields/algorithm/stopTimeFilter.js
+
+// Assuming moment-timezone is available in the project, as used elsewhere
+const moment = require('moment-timezone');
+
+// Import necessary helpers (adjust path if tableHelpers.js is elsewhere)
+// Or redefine shifts, parseTime, getMealTypeByTime here if preferred
+const { shifts, parseTime, getMealTypeByTime } = require('../tableHelpers');
+
+/**
+ * Gets the current time in minutes since midnight in the Brussels timezone.
+ * @returns {number} Current time in minutes.
+ */
+function getCurrentTimeInBrusselsMinutes() {
+    const now = moment().tz('Europe/Brussels');
+    return now.hours() * 60 + now.minutes();
+}
+
+/**
+ * Filters a list of timeblocks based on stop times defined in general settings.
+ * This filter only applies if the provided dateStr is the current date.
+ *
+ * @param {Object} timeblocks - An object where keys are time strings ("HH:MM") and values are timeblock data.
+ * @param {Object} restaurantData - The main restaurant data object containing general-settings.
+ * @param {string} dateStr - The date string ("YYYY-MM-DD") to check against today.
+ * @returns {Object} - The filtered timeblocks object.
+ */
+function filterTimeblocksByStopTimes(timeblocks, restaurantData, dateStr) {
+    // Determine today's date string in the correct timezone
+    const todayStr = moment().tz('Europe/Brussels').format('YYYY-MM-DD');
+
+    // Only apply the filter if the date being checked is today
+    if (dateStr !== todayStr) {
+        return timeblocks; // No filtering needed for future dates
+    }
+
+    console.log(`Applying stop time filter for today (${dateStr})`);
+
+    const settings = restaurantData?.['general-settings'] || {};
+    const currentTimeMinutes = getCurrentTimeInBrusselsMinutes();
+
+    // Get stop times from settings and parse them (handle missing/null values)
+    const breakfastStopTimeStr = settings.ontbijtStop || null; // e.g., "10:00"
+    const lunchStopTimeStr = settings.lunchStop || null;     // e.g., "14:00"
+    const dinnerStopTimeStr = settings.dinerStop || null;    // e.g., "20:00"
+
+    const breakfastStopTime = breakfastStopTimeStr ? parseTime(breakfastStopTimeStr) : null;
+    const lunchStopTime = lunchStopTimeStr ? parseTime(lunchStopTimeStr) : null;
+    const dinnerStopTime = dinnerStopTimeStr ? parseTime(dinnerStopTimeStr) : null;
+
+    // console.log(`Current time (minutes): ${currentTimeMinutes}`); // Verbose
+    // console.log(`Stop times (minutes) - Breakfast: ${breakfastStopTime}, Lunch: ${lunchStopTime}, Dinner: ${dinnerStopTime}`); // Verbose
+
+    const filteredTimeblocks = {};
+    let skippedBreakfast = 0;
+    let skippedLunch = 0;
+    let skippedDinner = 0;
+
+    for (const time in timeblocks) {
+        if (!timeblocks.hasOwnProperty(time)) continue;
+
+        const mealType = getMealTypeByTime(time);
+        let skip = false;
+
+        if (mealType === 'breakfast' && breakfastStopTime !== null && !isNaN(breakfastStopTime) && currentTimeMinutes >= breakfastStopTime) {
+            skip = true;
+            skippedBreakfast++;
+        } else if (mealType === 'lunch' && lunchStopTime !== null && !isNaN(lunchStopTime) && currentTimeMinutes >= lunchStopTime) {
+            skip = true;
+            skippedLunch++;
+        } else if (mealType === 'dinner' && dinnerStopTime !== null && !isNaN(dinnerStopTime) && currentTimeMinutes >= dinnerStopTime) {
+            skip = true;
+            skippedDinner++;
+        }
+
+        if (!skip) {
+            filteredTimeblocks[time] = timeblocks[time];
+        }
+    }
+
+    if (skippedBreakfast > 0) console.log(`Stop time filter removed ${skippedBreakfast} breakfast slots.`);
+    if (skippedLunch > 0) console.log(`Stop time filter removed ${skippedLunch} lunch slots.`);
+    if (skippedDinner > 0) console.log(`Stop time filter removed ${skippedDinner} dinner slots.`);
+
+    return filteredTimeblocks;
+}
+
+module.exports = {
+    filterTimeblocksByStopTimes
+};

package/getAvailableTimeblocks.js

@@ -0,0 +1,109 @@
+// getAvailableTimeblocks.js
+
+const { timeblocksAvailable } = require('./processing/timeblocksAvailable');
+
+/**
+ * Parses a time string in "HH:MM" format into a Date object on a specific date.
+ * @param {string} dateStr - The date string in "YYYY-MM-DD" format.
+ * @param {string} timeStr - Time string in "HH:MM" format.
+ * @param {string} timeZone - The IANA time zone identifier.
+ * @returns {Date} Date object representing the time on the specified date and time zone.
+ */
+function parseDateTimeInTimeZone(dateStr, timeStr, timeZone) {
+  const [year, month, day] = dateStr.split('-').map(Number);
+  const [hours, minutes] = timeStr.split(':').map(Number);
+
+  // Create a date object in UTC
+  const date = new Date(Date.UTC(year, month - 1, day, hours, minutes));
+  // Convert that UTC date/time to the specified time zone
+  const dateInTimeZone = new Date(
+    date.toLocaleString('en-US', { timeZone: timeZone })
+  );
+  return dateInTimeZone;
+}
+
+/**
+ * Gets the available time blocks or shifts for a reservation, considering 'uurOpVoorhand' and 'dagenInToekomst'.
+ * @param {Object} data - The main data object containing settings and meal information.
+ * @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.
+ * @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) {
+  // Get 'uurOpVoorhand' from general settings
+  let uurOpVoorhand = 4;
+  if (
+    data['general-settings'] &&
+    data['general-settings'].uurOpVoorhand &&
+    parseInt(data['general-settings'].uurOpVoorhand, 10) >= 0
+  ) {
+    uurOpVoorhand = parseInt(data['general-settings'].uurOpVoorhand, 10);
+  }
+
+  // Get 'dagenInToekomst' from general settings
+  let dagenInToekomst = 90; // Default if not defined
+  if (
+    data['general-settings'] &&
+    data['general-settings'].dagenInToekomst &&
+    parseInt(data['general-settings'].dagenInToekomst, 10) > 0
+  ) {
+    dagenInToekomst = parseInt(data['general-settings'].dagenInToekomst, 10);
+  }
+
+  // Time zone for CEST/CET (Europe/Amsterdam)
+  const timeZone = 'Europe/Amsterdam';
+
+  // Current date/time in CEST
+  const now = new Date();
+  const currentTimeInTimeZone = new Date(
+    now.toLocaleString('en-US', { timeZone: timeZone })
+  );
+
+  // Calculate the maximum allowed date
+  const maxAllowedDate = new Date(currentTimeInTimeZone.getTime());
+  maxAllowedDate.setDate(maxAllowedDate.getDate() + dagenInToekomst);
+  maxAllowedDate.setHours(23, 59, 59, 999);
+
+  // Parse the target date in the specified time zone
+  const [year, month, day] = dateStr.split('-').map(Number);
+  const targetDate = new Date(Date.UTC(year, month - 1, day));
+  const targetDateInTimeZone = new Date(
+    targetDate.toLocaleString('en-US', { timeZone: timeZone })
+  );
+
+  // Check if targetDateInTimeZone is within dagenInToekomst
+  if (targetDateInTimeZone > maxAllowedDate) {
+    // Out of allowed range, return empty object
+    return {};
+  }
+
+  // Check if the target date is today in the specified time zone
+  const isToday =
+    currentTimeInTimeZone.toDateString() === targetDateInTimeZone.toDateString();
+
+  // Get available time blocks or shifts
+  const availableTimeblocks = timeblocksAvailable(data, dateStr, reservations, guests);
+
+  // If the date is today and uurOpVoorhand is greater than zero, prune time blocks
+  if (isToday && uurOpVoorhand >= 0) {
+    const cutoffTime = new Date(currentTimeInTimeZone.getTime());
+    cutoffTime.setHours(cutoffTime.getHours() + uurOpVoorhand);
+
+    for (const [key, value] of Object.entries(availableTimeblocks)) {
+      let timeStr = key;
+
+      const timeBlockDateTime = parseDateTimeInTimeZone(dateStr, timeStr, timeZone);
+
+      if (timeBlockDateTime < cutoffTime) {
+        delete availableTimeblocks[key];
+      }
+    }
+  }
+
+  return availableTimeblocks;
+}
+
+module.exports = {
+  getAvailableTimeblocks,
+};

package/grouping.js

@@ -0,0 +1,162 @@
+// grouping.js
+/**
+ * Try to allocate a reservation via pinned groups.
+ * Returns { tables: number[], tableIds: string[], viaGroup: string } on success,
+ * null if grouping is enabled but no match (and strict=false),
+ * and throws if grouping is strict and no group matches.
+ *
+ * Dependencies (passed in): isTemporaryTableValid, isTableFreeForAllSlots
+ */
+function tryGroupTables({
+  restaurantSettings,
+  allTables,
+  guests,
+  date,
+  time,
+  requiredSlots,
+  tableOccupiedSlots,
+  isTemporaryTableValid,
+  isTableFreeForAllSlots,
+}) {
+  const gset = restaurantSettings["grouping-settings"] || {};
+  const groupingEnabled = gset.enable === true;
+  const groupingStrict = gset.strict === true;
+  const maxSubtablesPerGroup = Number.isFinite(gset.maxSubtables)
+    ? gset.maxSubtables
+    : undefined;
+  const orderStrategy = gset.orderStrategy || "smallest-first"; // 'smallest-first' | 'capacity-asc' | 'closest-fit'
+  const seed = gset.seed ?? 0;
+
+  const pinnedGroups = Array.isArray(restaurantSettings.pinnedGroups)
+    ? restaurantSettings.pinnedGroups
+    : [];
+
+  if (!groupingEnabled || pinnedGroups.length === 0) {
+    return null;
+  }
+
+  // Build lookups from allTables
+  const byId = new Map(allTables.map((t) => [String(t.tableId), t]));
+  const byNumber = new Map(
+    allTables
+      .filter((t) => typeof t.tableNumber === "number")
+      .map((t) => [t.tableNumber, t])
+  );
+
+  // Quick check: is there already a single-table fit?
+  const hasSingleFit = allTables.some(
+    (t) =>
+      t.minCapacity <= guests &&
+      guests <= t.maxCapacity &&
+      isTemporaryTableValid(t, date, time) &&
+      isTableFreeForAllSlots(t.tableNumber, requiredSlots, tableOccupiedSlots)
+  );
+  if (hasSingleFit) {
+    // Let caller handle single-table path; grouping is only used when no single table fits
+    return null;
+  }
+
+  // Stable group ordering
+  const stableGroups = [...pinnedGroups].sort((a, b) => {
+    const aid = String(a.id || a.name || "");
+    const bid = String(b.id || b.name || "");
+    return aid.localeCompare(bid);
+  });
+
+  // Deterministic RNG (kept for parity; not used by default)
+  const rnd = (() => {
+    let x = Math.imul(0x9e3779b1, (seed | 0) + 0x7f4a7c15) | 0;
+    return () => (
+      (x = (x ^ (x >>> 15)) * (x | 1)),
+      (x ^= x + Math.imul(x ^ (x >>> 7), x | 61)),
+      ((x ^ (x >>> 14)) >>> 0) / 4294967296
+    );
+  })();
+
+  // Subtable ordering strategy
+  const subSort = (a, b) => {
+    if (orderStrategy === "closest-fit") {
+      const slA = (a.maxCapacity || 0) - (a.minCapacity || 0);
+      const slB = (b.maxCapacity || 0) - (b.minCapacity || 0);
+      if (slA !== slB) return slA - slB;
+    }
+    if (a.maxCapacity !== b.maxCapacity) return a.maxCapacity - b.maxCapacity;
+    if (a.tableNumber !== b.tableNumber) return a.tableNumber - b.tableNumber;
+    const ida = String(a.tableId),
+      idb = String(b.tableId);
+    return ida.localeCompare(idb);
+  };
+
+  // Try each pinned group
+  for (const g of stableGroups) {
+    const rawIds = Array.isArray(g.tableIds) ? g.tableIds.map(String) : [];
+    const rawNums = Array.isArray(g.tableNumbers)
+      ? g.tableNumbers.filter((n) => typeof n === "number")
+      : [];
+
+    let subs = [];
+    if (rawIds.length) subs = rawIds.map((id) => byId.get(id)).filter(Boolean);
+    else if (rawNums.length)
+      subs = rawNums.map((n) => byNumber.get(n)).filter(Boolean);
+
+    if (maxSubtablesPerGroup && subs.length > maxSubtablesPerGroup) {
+      subs = subs.slice(0, maxSubtablesPerGroup);
+    }
+
+    if (subs.length < 2) continue;
+
+    // All subtables must be valid & free for all required slots
+    if (
+      !subs.every(
+        (t) =>
+          isTemporaryTableValid(t, date, time) &&
+          isTableFreeForAllSlots(
+            t.tableNumber,
+            requiredSlots,
+            tableOccupiedSlots
+          )
+      )
+    ) {
+      continue;
+    }
+
+    // Capacity checks
+    const totalMax = subs.reduce((s, t) => s + (t.maxCapacity || 0), 0);
+    const totalMin = subs.reduce((s, t) => s + (t.minCapacity || 0), 0);
+    if (guests < totalMin) continue;
+    if (guests > totalMax) continue;
+
+    // Deterministic allocation:
+    const ordered = [...subs].sort(subSort);
+    const alloc = new Map(
+      ordered.map((t) => [t.tableNumber, Math.max(0, t.minCapacity || 0)])
+    );
+    let remaining = guests - [...alloc.values()].reduce((s, v) => s + v, 0);
+    if (remaining < 0) continue;
+
+    for (const t of ordered) {
+      if (remaining <= 0) break;
+      const cur = alloc.get(t.tableNumber);
+      const addable = Math.max(0, (t.maxCapacity || 0) - cur);
+      const give = Math.min(addable, remaining);
+      alloc.set(t.tableNumber, cur + give);
+      remaining -= give;
+    }
+    if (remaining !== 0) continue; // couldn’t fit exactly
+
+    // Success
+    return {
+      tables: ordered.map((t) => t.tableNumber),
+      tableIds: ordered.map((t) => t.tableId),
+      viaGroup: String(g.id || g.name || "pinned-group"),
+    };
+  }
+
+  // No match
+  if (groupingStrict) {
+    throw new Error("No matching pinned group found (strict grouping)");
+  }
+  return null;
+}
+
+module.exports = { tryGroupTables };

package/index.js

@@ -0,0 +1,47 @@
+// algorithm/index.js
+
+const processing = {
+    ...require("./processing/dailyGuestCounts"),
+    ...require("./processing/mealTypeCount"),
+    ...require("./processing/timeblocksAvailable")
+};
+
+const reservation_data = {
+    ...require("./reservation_data/counter")
+};
+
+const restaurant_data = {
+    ...require("./restaurant_data/exceptions"),
+    ...require("./restaurant_data/openinghours")
+};
+
+const test = {
+    ...require("./assignTables"),
+    ...require("./getAvailableTimeblocks"),
+    ...require("./grouping"),
+    ...require("./isDateAvailable"),
+    ...require("./isTimeAvailable"),
+    ...require("./simulateTableAssignment"),
+    ...require("./isDateAvailableWithTableCheck"),
+    ...require("./tableHelpers"),
+    ...require("./test")
+};
+
+const filters = {
+    ...require("./filters/timeFilter"),
+    ...require("./filters/maxArrivalsFilter"),
+    ...require("./filters/maxGroupsFilter")
+};
+const tables = {
+    ...require("./tables/main.js"),
+
+};
+// Merge all exports into one
+module.exports = {
+    ...processing,
+    ...reservation_data,
+    ...restaurant_data,
+    ...test,
+    ...filters,
+    ...tables
+};