@happychef/algorithm 1.2.28 → 1.2.30

package/assignTables.js

@@ -236,9 +236,11 @@ async function assignTablesIfPossible({
       }
     }
 
-    // 2) Get floors data directly from the restaurant document
-    let floorsData = restaurantSettings.floors;
-    if (!floorsData || !Array.isArray(floorsData) || floorsData.length === 0) {
+    // 2) Get floors data directly from the restaurant document (include manualFloors)
+    const regularFloors = Array.isArray(restaurantSettings.floors) ? restaurantSettings.floors : [];
+    const manualFloors = Array.isArray(restaurantSettings.manualFloors) ? restaurantSettings.manualFloors : [];
+    let floorsData = [...regularFloors, ...manualFloors];
+    if (floorsData.length === 0) {
       if (enforceTableAvailability) {
         throw new Error('No floors data found in restaurant document.');
       } else {
@@ -257,21 +259,31 @@ async function assignTablesIfPossible({
       }
     }
 
-    // 3) Helper to collect tables from floors
+    // 3) Helper to safely parse int from MongoDB $numberInt or plain value
+    function safeInt(val, fallback) {
+      if (val == null) return fallback;
+      const raw = (typeof val === 'object' && val.$numberInt != null) ? val.$numberInt : val;
+      const parsed = parseInt(raw, 10);
+      return isNaN(parsed) ? fallback : parsed;
+    }
+
+    // 4) Helper to collect tables from floors
     function collectTablesFromFloors(floors) {
       const tables = [];
       floors.forEach(floor => {
         if (floor.tables && Array.isArray(floor.tables)) {
           floor.tables.forEach(tbl => {
             if (tbl.objectType === "Tafel") {
+              const tableNumber = safeInt(tbl.tableNumber, null);
+              if (tableNumber == null) return; // skip tables without a number
               tables.push({
                 tableId: tbl.id,
-                tableNumber: parseInt(tbl.tableNumber.$numberInt || tbl.tableNumber),
-                minCapacity: parseInt(tbl.minCapacity.$numberInt || tbl.minCapacity),
-                maxCapacity: parseInt(tbl.maxCapacity.$numberInt || tbl.maxCapacity),
-                priority: parseInt(tbl.priority.$numberInt || tbl.priority),
-                x: parseInt(tbl.x.$numberInt || tbl.x),
-                y: parseInt(tbl.y.$numberInt || tbl.y),
+                tableNumber,
+                minCapacity: safeInt(tbl.minCapacity, 1),
+                maxCapacity: safeInt(tbl.maxCapacity, 99),
+                priority: safeInt(tbl.priority, 99),
+                x: safeInt(tbl.x, 0),
+                y: safeInt(tbl.y, 0),
                 isTemporary: tbl.isTemporary === true,
                 startDate: tbl.startDate || null,
                 endDate: tbl.endDate || null,

package/bundle_entry.js

@@ -0,0 +1,100 @@
+// bundle_entry.js - Entry point for esbuild bundling
+// Exposes all @happychef/algorithm functions on globalThis.HappyAlgorithm
+// for use with flutter_js (QuickJS / JavaScriptCore)
+
+const algorithm = require('./index.js');
+
+// Intl.DateTimeFormat polyfill for QuickJS (which lacks Intl support)
+if (typeof globalThis.Intl === 'undefined' || typeof globalThis.Intl.DateTimeFormat === 'undefined') {
+  // EU DST rules for Europe/Brussels
+  function getBrusselsOffsetHours(date) {
+    const year = date.getUTCFullYear();
+    const marchLast = new Date(Date.UTC(year, 2, 31));
+    const marchSunday = 31 - marchLast.getUTCDay();
+    const dstStart = Date.UTC(year, 2, marchSunday, 1, 0, 0);
+    const octLast = new Date(Date.UTC(year, 9, 31));
+    const octSunday = 31 - octLast.getUTCDay();
+    const dstEnd = Date.UTC(year, 9, octSunday, 1, 0, 0);
+    const ts = date.getTime();
+    return (ts >= dstStart && ts < dstEnd) ? 2 : 1;
+  }
+
+  if (!globalThis.Intl) globalThis.Intl = {};
+
+  globalThis.Intl.DateTimeFormat = function IntlDateTimeFormat(locale, options) {
+    this._options = options || {};
+    this.formatToParts = function(date) {
+      const d = date || new Date();
+      const tz = (this._options.timeZone || '').replace(/\//g, '/');
+      // Only support Europe/Brussels
+      const offset = getBrusselsOffsetHours(d);
+      const brusselsDate = new Date(d.getTime() + offset * 60 * 60 * 1000);
+      const parts = [];
+      if (this._options.hour) {
+        parts.push({ type: 'hour', value: String(brusselsDate.getUTCHours()).padStart(2, '0') });
+      }
+      if (this._options.minute) {
+        parts.push({ type: 'literal', value: ':' });
+        parts.push({ type: 'minute', value: String(brusselsDate.getUTCMinutes()).padStart(2, '0') });
+      }
+      return parts;
+    };
+    this.format = function(date) {
+      return this.formatToParts(date).map(function(p) { return p.value; }).join('');
+    };
+  };
+}
+
+// Expose all algorithm functions globally
+globalThis.HappyAlgorithm = {
+  // Core availability functions
+  getAvailableTimeblocks: algorithm.getAvailableTimeblocks,
+  isDateAvailable: algorithm.isDateAvailable,
+  isDateAvailableWithTableCheck: algorithm.isDateAvailableWithTableCheck,
+  isTimeAvailable: algorithm.isTimeAvailable,
+
+  // Table assignment functions
+  isTimeAvailableSync: algorithm.isTimeAvailableSync,
+  filterTimeblocksByTableAvailability: algorithm.filterTimeblocksByTableAvailability,
+  getAvailableTimeblocksWithTableCheck: algorithm.getAvailableTimeblocksWithTableCheck,
+  getAvailableTablesForTime: algorithm.getAvailableTablesForTime,
+
+  // Processing functions
+  timeblocksAvailable: algorithm.timeblocksAvailable,
+  getDailyGuestCounts: algorithm.getDailyGuestCounts,
+
+  // Filter functions
+  filterTimeblocksByStopTimes: algorithm.filterTimeblocksByStopTimes,
+  filterTimeblocksByMaxArrivals: algorithm.filterTimeblocksByMaxArrivals,
+  filterTimeblocksByMaxGroups: algorithm.filterTimeblocksByMaxGroups,
+
+  // Table helpers
+  parseTime: algorithm.parseTime,
+  getMealTypeByTime: algorithm.getMealTypeByTime,
+  getAllTables: algorithm.getAllTables,
+  getFloorIdForSeatPlace: algorithm.getFloorIdForSeatPlace,
+  isTemporaryTableValid: algorithm.isTemporaryTableValid,
+
+  // Grouping
+  tryGroupTables: algorithm.tryGroupTables,
+
+  // Batch functions for calendar performance (avoid 30 separate JSON serializations)
+  batchIsDateAvailable: function(data, dates, reservations, guests, blockedSlots, giftcard, isAdmin, duration) {
+    var result = {};
+    for (var i = 0; i < dates.length; i++) {
+      result[dates[i]] = algorithm.isDateAvailable(data, dates[i], reservations, guests, blockedSlots, giftcard, isAdmin, duration);
+    }
+    return result;
+  },
+
+  batchIsDateAvailableWithTableCheck: function(data, dates, reservations, guests, blockedSlots, selectedGiftcard, isAdmin, duration, selectedZitplaats) {
+    var result = {};
+    for (var i = 0; i < dates.length; i++) {
+      result[dates[i]] = algorithm.isDateAvailableWithTableCheck(data, dates[i], reservations, guests, blockedSlots, selectedGiftcard, isAdmin, duration, selectedZitplaats);
+    }
+    return result;
+  },
+
+  // Version info
+  VERSION: '1.2.29'
+};

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.2.28",
+  "version": "1.2.30",
   "description": "Restaurant and reservation algorithm utilities",
   "main": "index.js",
   "scripts": {

package/tableHelpers.js

@@ -72,63 +72,71 @@ function getFloorIdForSeatPlace(restaurantData, seatPlace) {
  * @param {string|null} selectedZitplaats - Optional seat place to filter by linked floor.
  * @returns {Array} An array of processed table objects.
  */
+/**
+ * Safely parse int from MongoDB $numberInt or plain value, with fallback.
+ */
+function safeInt(val, fallback) {
+    if (val == null) return fallback;
+    if (typeof val === 'object' && val !== null && val.$numberInt != null) {
+        const parsed = parseInt(val.$numberInt, 10);
+        return isNaN(parsed) ? fallback : parsed;
+    }
+    if (typeof val === 'number' && !isNaN(val)) return val;
+    const parsed = parseInt(val, 10);
+    return isNaN(parsed) ? fallback : parsed;
+}
+
 function getAllTables(restaurantData, selectedZitplaats) {
     let allTables = [];
-    if (restaurantData?.floors && Array.isArray(restaurantData.floors)) {
-        // If a zitplaats is specified and has a floor link, only use that floor
-        let floorsToUse = restaurantData.floors;
-        if (selectedZitplaats) {
-            const linkedFloorId = getFloorIdForSeatPlace(restaurantData, selectedZitplaats);
-            if (linkedFloorId) {
-                const linkedFloor = restaurantData.floors.find(f => f.id === linkedFloorId);
-                if (linkedFloor) {
-                    floorsToUse = [linkedFloor];
-                    console.log(`[getAllTables] Floor link found: zitplaats '${selectedZitplaats}' -> floor '${linkedFloorId}'`);
-                }
+    // Combine regular floors and manualFloors
+    const regularFloors = Array.isArray(restaurantData?.floors) ? restaurantData.floors : [];
+    const manualFloors = Array.isArray(restaurantData?.manualFloors) ? restaurantData.manualFloors : [];
+    let allFloors = [...regularFloors, ...manualFloors];
+
+    if (allFloors.length === 0) {
+        console.warn("Restaurant data is missing 'floors' array.");
+        return allTables;
+    }
+
+    // If a zitplaats is specified and has a floor link, only use that floor
+    let floorsToUse = allFloors;
+    if (selectedZitplaats) {
+        const linkedFloorId = getFloorIdForSeatPlace(restaurantData, selectedZitplaats);
+        if (linkedFloorId) {
+            const linkedFloor = allFloors.find(f => f.id === linkedFloorId);
+            if (linkedFloor) {
+                floorsToUse = [linkedFloor];
+                console.log(`[getAllTables] Floor link found: zitplaats '${selectedZitplaats}' -> floor '${linkedFloorId}'`);
             }
         }
+    }
 
-        floorsToUse.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;
-
-                    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'
-                        });
-                    } else if (tbl.objectType === "Tafel") {
-                        console.warn(`Skipping table due to missing essential properties: ${JSON.stringify(tbl)}`);
+    floorsToUse.forEach(floor => {
+        if (floor?.tables && Array.isArray(floor.tables)) {
+            floor.tables.forEach(tbl => {
+                if (tbl.objectType === "Tafel") {
+                    const tableNumber = safeInt(tbl.tableNumber, NaN);
+                    if (isNaN(tableNumber)) {
+                        console.warn(`Skipping table without valid tableNumber: ${JSON.stringify(tbl)}`);
+                        return;
                     }
-                });
-            }
-        });
-    } else {
-        console.warn("Restaurant data is missing 'floors' array.");
-    }
+                    allTables.push({
+                        tableId: tbl.id,
+                        tableNumber,
+                        minCapacity: safeInt(tbl.minCapacity, 1),
+                        maxCapacity: safeInt(tbl.maxCapacity, 99),
+                        priority: safeInt(tbl.priority, 99),
+                        x: safeInt(tbl.x, 0),
+                        y: safeInt(tbl.y, 0),
+                        isTemporary: tbl.isTemporary === true,
+                        startDate: tbl.startDate || null,
+                        endDate: tbl.endDate || null,
+                        application: tbl.application || null
+                    });
+                }
+            });
+        }
+    });
 
     // Sort tables
     allTables.sort((a, b) => {
@@ -136,22 +144,11 @@ function getAllTables(restaurantData, selectedZitplaats) {
             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;
 }