@happychef/algorithm 1.4.0 → 1.4.1

package/getAvailableTimeblocks.js

@@ -150,6 +150,18 @@ function getAvailableTimeblocks(data, dateStr, reservations, guests, blockedSlot
     }
   }
 
+  // For bowling venues, cap dinner time slots at 24:00 max
+  const isBowling = data?.account_type === 'bowling' || data?.accountType === 'bowling' || data?.['general-settings']?.account_type === 'bowling';
+  if (isBowling) {
+    for (const time in availableTimeblocks) {
+      const [h, m] = time.split(':').map(Number);
+      const timeMinutes = h * 60 + m;
+      if (timeMinutes > 1440) { // > 24:00
+        delete availableTimeblocks[time];
+      }
+    }
+  }
+
   return availableTimeblocks;
 }
 

package/index.js

@@ -15,10 +15,6 @@ const restaurant_data = {
     ...require("./restaurant_data/openinghours")
 };
 
-const dateHelpers = {
-    ...require("./dateHelpers")
-};
-
 const test = {
     ...require("./assignTables"),
     ...require("./getAvailableTimeblocks"),
@@ -28,8 +24,7 @@ const test = {
     ...require("./simulateTableAssignment"),
     ...require("./isDateAvailableWithTableCheck"),
     ...require("./tableHelpers"),
-    ...require("./test"),
-    ...require("./getDateClosingReasons")
+    ...require("./test")
 };
 
 const filters = {
@@ -42,7 +37,6 @@ module.exports = {
     ...processing,
     ...reservation_data,
     ...restaurant_data,
-    ...dateHelpers,
     ...test,
     ...filters
 };

package/jest.config.js

@@ -1,23 +1,23 @@
-module.exports = {
-  testEnvironment: 'node',
-  coverageDirectory: 'coverage',
-  collectCoverageFrom: [
-    '**/*.js',
-    '!**/node_modules/**',
-    '!**/coverage/**',
-    '!jest.config.js',
-    '!test.js',
-    '!test-*.js',
-    '!**/__tests__/**'
-  ],
-  testMatch: [
-    '**/__tests__/**/*.test.js'
-  ],
-  testPathIgnorePatterns: [
-    '/node_modules/',
-    '/test\\.js$',
-    '/test-.*\\.js$'
-  ],
-  verbose: true,
-  testTimeout: 10000
-};
+module.exports = {
+  testEnvironment: 'node',
+  coverageDirectory: 'coverage',
+  collectCoverageFrom: [
+    '**/*.js',
+    '!**/node_modules/**',
+    '!**/coverage/**',
+    '!jest.config.js',
+    '!test.js',
+    '!test-*.js',
+    '!**/__tests__/**'
+  ],
+  testMatch: [
+    '**/__tests__/**/*.test.js'
+  ],
+  testPathIgnorePatterns: [
+    '/node_modules/',
+    '/test\\.js$',
+    '/test-.*\\.js$'
+  ],
+  verbose: true,
+  testTimeout: 10000
+};

package/moment-timezone-shim.js

@@ -0,0 +1,179 @@
+// Minimal moment-timezone shim for Europe/Brussels only
+// Replaces the full ~500KB moment-timezone library
+// Implements only the subset used by @happychef/algorithm
+
+const TIMEZONE = 'Europe/Brussels';
+
+// EU DST rules: CET (UTC+1) / CEST (UTC+2)
+// CEST starts last Sunday of March at 02:00 UTC
+// CET starts last Sunday of October at 03:00 UTC
+function getBrusselsOffset(date) {
+  const year = date.getUTCFullYear();
+  const month = date.getUTCMonth(); // 0-indexed
+
+  // Find last Sunday of March
+  const marchLast = new Date(Date.UTC(year, 2, 31));
+  const marchSunday = 31 - marchLast.getUTCDay();
+  const dstStart = Date.UTC(year, 2, marchSunday, 1, 0, 0); // 02:00 CET = 01:00 UTC
+
+  // Find last Sunday of October
+  const octLast = new Date(Date.UTC(year, 9, 31));
+  const octSunday = 31 - octLast.getUTCDay();
+  const dstEnd = Date.UTC(year, 9, octSunday, 1, 0, 0); // 03:00 CEST = 01:00 UTC
+
+  const ts = date.getTime();
+  if (ts >= dstStart && ts < dstEnd) {
+    return 2; // CEST (UTC+2)
+  }
+  return 1; // CET (UTC+1)
+}
+
+function toBrusselsDate(date) {
+  const offset = getBrusselsOffset(date);
+  return new Date(date.getTime() + offset * 60 * 60 * 1000);
+}
+
+function createMomentObject(date, offset) {
+  const brusselsDate = new Date(date.getTime() + offset * 60 * 60 * 1000);
+
+  const obj = {
+    _date: date,
+    _brusselsDate: brusselsDate,
+    _offset: offset,
+    _valid: true,
+
+    isValid() {
+      return this._valid;
+    },
+
+    day() {
+      return this._brusselsDate.getUTCDay();
+    },
+
+    hours() {
+      return this._brusselsDate.getUTCHours();
+    },
+
+    minutes() {
+      return this._brusselsDate.getUTCMinutes();
+    },
+
+    format(fmt) {
+      if (fmt === 'YYYY-MM-DD') {
+        const y = this._brusselsDate.getUTCFullYear();
+        const m = String(this._brusselsDate.getUTCMonth() + 1).padStart(2, '0');
+        const d = String(this._brusselsDate.getUTCDate()).padStart(2, '0');
+        return `${y}-${m}-${d}`;
+      }
+      if (fmt === 'HH:mm') {
+        const h = String(this._brusselsDate.getUTCHours()).padStart(2, '0');
+        const min = String(this._brusselsDate.getUTCMinutes()).padStart(2, '0');
+        return `${h}:${min}`;
+      }
+      return this._brusselsDate.toISOString();
+    },
+
+    startOf(unit) {
+      if (unit === 'day') {
+        const d = new Date(Date.UTC(
+          this._brusselsDate.getUTCFullYear(),
+          this._brusselsDate.getUTCMonth(),
+          this._brusselsDate.getUTCDate(),
+          0, 0, 0, 0
+        ));
+        // Adjust back from Brussels to UTC
+        const utcDate = new Date(d.getTime() - this._offset * 60 * 60 * 1000);
+        return createMomentObject(utcDate, this._offset);
+      }
+      return this;
+    },
+
+    endOf(unit) {
+      if (unit === 'day') {
+        const d = new Date(Date.UTC(
+          this._brusselsDate.getUTCFullYear(),
+          this._brusselsDate.getUTCMonth(),
+          this._brusselsDate.getUTCDate(),
+          23, 59, 59, 999
+        ));
+        const utcDate = new Date(d.getTime() - this._offset * 60 * 60 * 1000);
+        return createMomentObject(utcDate, this._offset);
+      }
+      return this;
+    },
+
+    isBefore(other) {
+      return this._date.getTime() < other._date.getTime();
+    },
+
+    isAfter(other) {
+      return this._date.getTime() > other._date.getTime();
+    },
+
+    tz() {
+      // Already in Brussels timezone, return self
+      return this;
+    },
+  };
+
+  return obj;
+}
+
+function parseDateStr(dateStr, format) {
+  if (format === 'YYYY-MM-DD') {
+    const parts = dateStr.split('-');
+    if (parts.length !== 3) return null;
+    const year = parseInt(parts[0], 10);
+    const month = parseInt(parts[1], 10) - 1;
+    const day = parseInt(parts[2], 10);
+    if (isNaN(year) || isNaN(month) || isNaN(day)) return null;
+    if (month < 0 || month > 11 || day < 1 || day > 31) return null;
+    // Create date at midnight Brussels time -> convert to UTC
+    const utcDate = new Date(Date.UTC(year, month, day, 0, 0, 0));
+    return utcDate;
+  }
+  return null;
+}
+
+// Main moment function
+function moment(dateStr, format, timezone) {
+  if (dateStr === undefined || dateStr === null) {
+    // moment() - current time
+    const now = new Date();
+    const offset = getBrusselsOffset(now);
+    const obj = createMomentObject(now, offset);
+    obj.tz = function() { return obj; };
+    return obj;
+  }
+
+  if (typeof dateStr === 'string') {
+    const date = parseDateStr(dateStr, format || 'YYYY-MM-DD');
+    if (!date) {
+      return { _valid: false, isValid() { return false; }, day() { return 0; }, tz() { return this; } };
+    }
+    const offset = getBrusselsOffset(date);
+    return createMomentObject(date, offset);
+  }
+
+  // Fallback
+  const now = new Date();
+  const offset = getBrusselsOffset(now);
+  return createMomentObject(now, offset);
+}
+
+// moment.tz(dateStr, format, timezone) or moment().tz(timezone)
+moment.tz = function(dateStr, format, timezone) {
+  if (typeof dateStr === 'string' && typeof format === 'string' && typeof timezone === 'string') {
+    // moment.tz(dateStr, format, timezone)
+    return moment(dateStr, format, timezone);
+  }
+  if (typeof dateStr === 'string' && typeof format === 'string' && timezone === undefined) {
+    // moment.tz(dateStr, timezone) - dateStr is actual date, format is timezone
+    // This pattern: moment().tz('Europe/Brussels')
+    return moment(dateStr, 'YYYY-MM-DD');
+  }
+  // Fallback: current time in Brussels
+  return moment();
+};
+
+module.exports = moment;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@happychef/algorithm",
-  "version": "1.4.0",
+  "version": "1.4.1",
   "description": "Restaurant and reservation algorithm utilities",
   "main": "index.js",
   "scripts": {

package/processing/timeblocksAvailable.js

@@ -1,9 +1,7 @@
 const { getDailyGuestCounts } = require('./dailyGuestCounts');
 const { getMealTypesWithShifts } = require('./mealTypeCount');
 const { getDataByDateAndMealWithExceptions } = require('../restaurant_data/exceptions');
-const { getMealTypeByTime, daysOfWeekEnglish } = require('../restaurant_data/openinghours');
-const { getGuestCountAtHour } = require('../reservation_data/counter');
-const { getNextDateStr } = require('../dateHelpers');
+const { getMealTypeByTime, parseTime: parseTimeOH, daysOfWeekEnglish } = require('../restaurant_data/openinghours');
 const moment = require('moment-timezone');
 
 /**
@@ -41,38 +39,6 @@ function getDuurReservatie(data) {
   return duurReservatie;
 }
 
-function getHoursOpenedPastMidnight(data, dateStr) {
-  // Per-day value from dinner opening hours
-  const m = moment.tz(dateStr, 'YYYY-MM-DD', 'Europe/Brussels');
-  if (m.isValid()) {
-    const day = daysOfWeekEnglish[m.day()];
-    const dinnerSettings = data['openinghours-dinner']?.schemeSettings?.[day];
-    if (dinnerSettings?.hoursOpenedPastMidnight !== undefined) {
-      const parsed = parseInt(dinnerSettings.hoursOpenedPastMidnight, 10);
-      return (!isNaN(parsed) && parsed > 0) ? parsed : 0;
-    }
-  }
-  // Fallback: global setting from general-settings (backward compat)
-  const val = data['general-settings']?.hoursOpenedPastMidnight;
-  const parsed = parseInt(val, 10);
-  return (!isNaN(parsed) && parsed > 0) ? parsed : 0;
-}
-
-/**
- * Checks if hoursOpenedPastMidnight is explicitly defined in settings.
- * Used to distinguish bowling restaurants (who set it) from regular ones (who don't).
- */
-function hasMidnightSetting(data, dateStr) {
-  const m = moment.tz(dateStr, 'YYYY-MM-DD', 'Europe/Brussels');
-  if (m.isValid()) {
-    const day = daysOfWeekEnglish[m.day()];
-    const dinnerSettings = data['openinghours-dinner']?.schemeSettings?.[day];
-    if (dinnerSettings?.hoursOpenedPastMidnight !== undefined) return true;
-  }
-  const val = data['general-settings']?.hoursOpenedPastMidnight;
-  return val !== undefined && val !== null;
-}
-
 /**
  * Checks if a time slot belongs to a meal that has the selected giftcard enabled.
  */
@@ -104,73 +70,32 @@ function timeHasGiftcard(data, dateStr, timeStr, giftcard) {
 }
 
 /**
- * Determines if a given start time fits within any meal's timeframe.
- * For bowling restaurants (hasMidnightSetting), the extended endTime is used so that
- * slots like 23:15, 24:00 are valid start times.
- * For regular restaurants, uses the original production logic:
- *   startTime + duurReservatie <= mealEndTime
- * which naturally caps the last bookable slot (e.g. 22:45 for 23:00 close + 15min interval).
+ * Determines if a given start time plus duurReservatie fits within the meal timeframe.
  */
 function fitsWithinMeal(data, dateStr, startTimeStr, duurReservatie) {
-  const startTime = parseTime(startTimeStr);
-
-  // Original production logic for breakfast/lunch (always, regardless of bowling)
+  // Determine the meal type based on the start time
   const mealType = getMealTypeByTime(startTimeStr);
-  if (mealType === 'breakfast' || mealType === 'lunch') {
-    const mealData = getDataByDateAndMealWithExceptions(data, dateStr, mealType);
-    if (!mealData) return false;
-    const mealStartTime = parseTime(mealData.startTime);
-    const mealEndTime = parseTime(mealData.endTime);
-    return startTime >= mealStartTime && startTime + duurReservatie <= mealEndTime;
-  }
-
-  if (hasMidnightSetting(data, dateStr)) {
-    // Bowling dinner: allow start times up to extended endTime (e.g. 24:00)
-    const dinnerData = getDataByDateAndMealWithExceptions(data, dateStr, 'dinner');
-    if (!dinnerData) return false;
-    const dinnerStart = parseTime(dinnerData.startTime);
-    const dinnerEnd = parseTime(dinnerData.endTime);
-    return startTime >= dinnerStart && startTime <= dinnerEnd;
-  }
-
-  // Regular restaurant dinner: original production logic
   if (!mealType) return false;
+
+  // Get the meal data (with exceptions applied)
   const mealData = getDataByDateAndMealWithExceptions(data, dateStr, mealType);
   if (!mealData) return false;
+
   const mealStartTime = parseTime(mealData.startTime);
-  const mealEndTime = parseTime(mealData.endTime);
-  return startTime >= mealStartTime && startTime + duurReservatie <= mealEndTime;
-}
+  const mealEndTime = parseTime(mealData.endTime); // Already includes restaurant's duurReservatie
+  const startTime = parseTime(startTimeStr);
 
-/**
- * Converts minutes since midnight to "HH:MM" string.
- */
-function minutesToTimeStr(minutes) {
-  const h = Math.floor(minutes / 60);
-  const m = minutes % 60;
-  return `${String(h).padStart(2, '0')}:${String(m).padStart(2, '0')}`;
-}
+  // mealEndTime includes the restaurant's base duurReservatie (added by addDuurReservatieToEndTime).
+  // Recover the actual closing time so bookings can't START after the venue closes,
+  // even when the user picks a shorter duration than the restaurant's default.
+  const restaurantDuur = getDuurReservatie(data);
+  const actualMealEnd = mealEndTime - restaurantDuur;
 
-/**
- * Gets the max capacity for a time on a given date by checking all meals.
- * Returns 0 if no meal covers the time (restaurant is closed at that time).
- */
-function getMaxCapacityForTime(data, dateStr, timeMinutes) {
-  for (const mealType of ['breakfast', 'lunch', 'dinner']) {
-    const mealData = getDataByDateAndMealWithExceptions(data, dateStr, mealType);
-    if (!mealData) continue;
-    const mealStart = parseTime(mealData.startTime);
-    const mealEnd = parseTime(mealData.endTime);
-    if (timeMinutes >= mealStart && timeMinutes <= mealEnd) {
-      return parseInt(mealData.maxCapacity, 10) || 0;
-    }
-  }
-  return 0;
+  return startTime >= mealStartTime && startTime <= actualMealEnd && startTime + duurReservatie <= mealEndTime;
 }
 
 function timeblocksAvailable(data, dateStr, reservations, guests, blockedSlots = [], giftcard = null, isAdmin = false, duration = null) {
-  const defaultDuurReservatie = getDuurReservatie(data);
-  const duurReservatie = duration && duration > 0 ? duration : defaultDuurReservatie;
+  const duurReservatie = duration && duration > 0 ? duration : getDuurReservatie(data);
   const intervalReservatie = getInterval(data);
 
   // Slots needed
@@ -179,42 +104,6 @@ function timeblocksAvailable(data, dateStr, reservations, guests, blockedSlots =
   // Get guest counts and shifts info
   const { guestCounts, shiftsInfo } = getDailyGuestCounts(data, dateStr, reservations);
 
-  // If custom duration exceeds default, extend guestCounts with additional slots
-  // so that late-evening reservations have enough consecutive slots to check against.
-  const hoursOpenedPastMidnight = getHoursOpenedPastMidnight(data, dateStr);
-  if (duurReservatie > defaultDuurReservatie && guestCounts && Object.keys(guestCounts).length > 0) {
-    const existingSlots = Object.keys(guestCounts).map(parseTime);
-    const maxExistingSlot = Math.max(...existingSlots);
-    const extraMinutes = duurReservatie - defaultDuurReservatie;
-    const extendedEnd = maxExistingSlot + extraMinutes;
-
-    // Find the last meal's maxCapacity for use with spillover slots
-    const lastMealMaxCap = getMaxCapacityForTime(data, dateStr, maxExistingSlot);
-
-    for (let t = maxExistingSlot + intervalReservatie; t <= extendedEnd; t += intervalReservatie) {
-      const timeStr = minutesToTimeStr(t);
-      if (!(timeStr in guestCounts)) {
-        if (t >= 1440) {
-          // Cross-midnight slot: use hoursOpenedPastMidnight limit and last meal's capacity
-          const spilloverMinutes = t - 1440;
-          if (hoursOpenedPastMidnight > 0 && spilloverMinutes < hoursOpenedPastMidnight * 60) {
-            const gc = getGuestCountAtHour(data, reservations, minutesToTimeStr(spilloverMinutes), getNextDateStr(dateStr));
-            if (lastMealMaxCap > 0) {
-              guestCounts[timeStr] = lastMealMaxCap - gc;
-            }
-          }
-        } else {
-          // Same-day extended slot
-          const gc = getGuestCountAtHour(data, reservations, timeStr, dateStr);
-          const maxCap = getMaxCapacityForTime(data, dateStr, t);
-          if (maxCap > 0) {
-            guestCounts[timeStr] = maxCap - gc;
-          }
-        }
-      }
-    }
-  }
-
   const availableTimeblocks = {};
 
   // Handle shifts first
@@ -235,73 +124,27 @@ function timeblocksAvailable(data, dateStr, reservations, guests, blockedSlots =
   if (guestCounts && Object.keys(guestCounts).length > 0) {
     const timeSlots = Object.keys(guestCounts).sort((a, b) => parseTime(a) - parseTime(b));
 
-    for (let i = 0; i < timeSlots.length; i++) {
-      // Check capacity for the first slot
+    for (let i = 0; i <= timeSlots.length - slotsNeeded; i++) {
+      // Check capacity for all needed slots
+      let consecutiveSlotsAvailable = true;
       if (guestCounts[timeSlots[i]] < guests) {
         continue;
       }
 
-      const startMinutes = parseTime(timeSlots[i]);
-      let consecutiveSlotsAvailable = true;
-
+      let previousTime = parseTime(timeSlots[i]);
       for (let j = 1; j < slotsNeeded; j++) {
-        const neededMinutes = startMinutes + j * intervalReservatie;
-
-        // First try same-day check from guestCounts.
-        // This handles both regular times AND extended meal times (e.g. "24:00", "24:30")
-        // produced by addDuurReservatieToEndTime. Without this, regular restaurants would
-        // break near midnight because the cross-midnight branch rejects when hoursOpenedPastMidnight=0.
-        const slotIndex = i + j;
-        if (slotIndex < timeSlots.length) {
-          const currentTimeSlot = timeSlots[slotIndex];
-          const currentTime = parseTime(currentTimeSlot);
-          if (currentTime === neededMinutes) {
-            if (guestCounts[currentTimeSlot] < guests) {
-              consecutiveSlotsAvailable = false;
-              break;
-            }
-            continue; // Slot available via guestCounts
-          }
-        }
-
-        // Slot not found in guestCounts — check cross-midnight if applicable
-        if (neededMinutes >= 1440) {
-          if (hoursOpenedPastMidnight <= 0) {
-            consecutiveSlotsAvailable = false;
-            break;
-          }
-          const spilloverMinutes = neededMinutes - 1440;
-          if (spilloverMinutes >= hoursOpenedPastMidnight * 60) {
-            consecutiveSlotsAvailable = false;
-            break;
-          }
-          // Use starting meal's capacity as limit for spillover period
-          const nextDateStr = getNextDateStr(dateStr);
-          const nextTimeStr = minutesToTimeStr(spilloverMinutes);
-          const nextDayGuestCount = getGuestCountAtHour(data, reservations, nextTimeStr, nextDateStr);
-          const startMealCap = getMaxCapacityForTime(data, dateStr, startMinutes);
-          if (startMealCap - nextDayGuestCount < guests) {
-            consecutiveSlotsAvailable = false;
-            break;
-          }
-          continue; // Cross-midnight slot OK
-        }
-
-        // Not in guestCounts and not cross-midnight — gap in availability
-        consecutiveSlotsAvailable = false;
-        break;
-      }
+        const currentTimeSlot = timeSlots[i + j];
+        const currentTime = parseTime(currentTimeSlot);
 
-      // If the reservation would end past midnight, enforce hoursOpenedPastMidnight limit
-      // Only applies when the setting is explicitly defined (bowling restaurants).
-      if (consecutiveSlotsAvailable && hasMidnightSetting(data, dateStr)) {
-        const endMinutes = startMinutes + duurReservatie;
-        if (endMinutes > 1440 + hoursOpenedPastMidnight * 60) {
+        // Check interval and capacity
+        if ((currentTime - previousTime) !== intervalReservatie || guestCounts[currentTimeSlot] < guests) {
           consecutiveSlotsAvailable = false;
+          break;
         }
+        previousTime = currentTime;
       }
 
-      // If all consecutive slots are available, check if the start time fits within a meal
+      // If all consecutive slots are available, check if the full duration fits
       if (consecutiveSlotsAvailable && fitsWithinMeal(data, dateStr, timeSlots[i], duurReservatie)) {
         // Check if time matches giftcard requirement
         if (timeHasGiftcard(data, dateStr, timeSlots[i], giftcard)) {