@happychef/algorithm 1.2.27 → 1.2.29

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.28'
+};

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/nul

@@ -1,13 +0,0 @@
-
-Envoi d'une requ�te 'Ping'  127.0.0.1 avec 32 octets de donn�es�:
-R�ponse de 127.0.0.1�: octets=32 temps<1ms TTL=128
-R�ponse de 127.0.0.1�: octets=32 temps<1ms TTL=128
-R�ponse de 127.0.0.1�: octets=32 temps<1ms TTL=128
-R�ponse de 127.0.0.1�: octets=32 temps<1ms TTL=128
-R�ponse de 127.0.0.1�: octets=32 temps<1ms TTL=128
-R�ponse de 127.0.0.1�: octets=32 temps<1ms TTL=128
-
-Statistiques Ping pour 127.0.0.1:
-    Paquets�: envoy�s = 6, re�us = 6, perdus = 0 (perte 0%),
-Dur�e approximative des boucles en millisecondes :
-    Minimum = 0ms, Maximum = 0ms, Moyenne = 0ms

package/package.json

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

package/simulateTableAssignment.js

@@ -503,7 +503,7 @@ function isTimeAvailableSync(restaurantData, date, time, guests, reservations, s
             } else {
                 // ... simulation log ...
                 console.log(`[isTimeAvailableSync] No actual table data, simulating assignment for reservation`);
-                assignedTables = assignTablesForGivenTime(restaurantData, r.date, r.time, r.guests, tableOccupiedSlots, null, rDuration); // Simulation
+                assignedTables = assignTablesForGivenTime(restaurantData, r.date, r.time, r.guests, tableOccupiedSlots, r.zitplaats || null, rDuration); // Simulation - use reservation's own zitplaats
             }
 
             // Update the occupancy map based on the actual or simulated assignment
@@ -679,9 +679,9 @@ function getAvailableTablesForTime(restaurantData, date, time, guests, reservati
             if (actualTables.length > 0) {
                 assignedTables = actualTables;
             } else {
-                assignedTables = assignTablesForGivenTime(restaurantData, r.date, r.time, r.guests, tableOccupiedSlots, null, rDuration);
+                assignedTables = assignTablesForGivenTime(restaurantData, r.date, r.time, r.guests, tableOccupiedSlots, r.zitplaats || null, rDuration);
             }
-            
+
             if (assignedTables.length > 0) {
                 const rSlots = computeRequiredSlots(r.time, rDuration, intervalReservatie);
                  if (!rSlots || rSlots.length === 0) continue;