@xiboplayer/schedule 0.7.2 → 0.7.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xiboplayer/schedule",
-  "version": "0.7.2",
+  "version": "0.7.4",
   "description": "Complete scheduling solution: campaigns, dayparting, interrupts, and overlays",
   "type": "module",
   "main": "./src/index.js",
@@ -12,10 +12,10 @@
     "./overlays": "./src/overlays.js"
   },
   "dependencies": {
-    "@xiboplayer/utils": "0.7.2"
+    "@xiboplayer/utils": "0.7.4"
   },
   "devDependencies": {
-    "vitest": "^2.0.0"
+    "vitest": "^2.1.9"
   },
   "keywords": [
     "xibo",

package/src/overlays.js

@@ -111,23 +111,29 @@ export class OverlayScheduler {
   }
 
   /**
-   * Check if overlay is within its time window
+   * Check if overlay is within its time window.
+   * Delegates to ScheduleManager.isTimeActive() which handles both
+   * simple date ranges and recurring schedule dayparting.
+   * Falls back to basic date-range check if no scheduleManager is set.
+   *
    * @param {Object} overlay - Overlay object
    * @param {Date} now - Current time
    * @returns {boolean}
    */
   isTimeActive(overlay, now) {
-    const from = (overlay.fromdt || overlay.fromDt) ? new Date(overlay.fromdt || overlay.fromDt) : null;
-    const to = (overlay.todt || overlay.toDt) ? new Date(overlay.todt || overlay.toDt) : null;
-
-    // Check time bounds
-    if (from && now < from) {
-      return false;
-    }
-    if (to && now > to) {
-      return false;
+    if (this.scheduleManager) {
+      // Normalize fromDt → fromdt for ScheduleManager compatibility
+      const normalized = { ...overlay };
+      if (!normalized.fromdt && normalized.fromDt) normalized.fromdt = normalized.fromDt;
+      if (!normalized.todt && normalized.toDt) normalized.todt = normalized.toDt;
+      return this.scheduleManager.isTimeActive(normalized, now);
     }
 
+    // Fallback: basic date-range check (no scheduleManager available)
+    const from = (overlay.fromdt || overlay.fromDt) ? new Date(overlay.fromdt || overlay.fromDt) : null;
+    const to = (overlay.todt || overlay.toDt) ? new Date(overlay.todt || overlay.toDt) : null;
+    if (from && now < from) return false;
+    if (to && now > to) return false;
     return true;
   }
 
@@ -159,18 +165,6 @@ export class OverlayScheduler {
     logger.debug('Cleared all overlays');
   }
 
-  /**
-   * Process overlay layouts (compatibility method for interrupt scheduler pattern)
-   * @param {Array} layouts - Base layouts
-   * @param {Array} overlays - Overlay layouts
-   * @returns {Array} Layouts (unchanged, overlays are separate)
-   */
-  processOverlays(layouts, overlays) {
-    // Overlays don't modify the main layout loop
-    // They are rendered separately on top
-    this.setOverlays(overlays);
-    return layouts;
-  }
 }
 
 export const overlayScheduler = new OverlayScheduler();

package/src/overlays.test.js

@@ -162,6 +162,13 @@ describe('OverlayScheduler', () => {
     it('filters by geo-fence when isGeoAware', () => {
       const mockScheduleManager = {
         isWithinGeoFence: () => false,
+        isTimeActive: (item, now) => {
+          const from = item.fromdt ? new Date(item.fromdt) : null;
+          const to = item.todt ? new Date(item.todt) : null;
+          if (from && now < from) return false;
+          if (to && now > to) return false;
+          return true;
+        },
       };
       scheduler.setScheduleManager(mockScheduleManager);
 
@@ -219,7 +226,7 @@ describe('OverlayScheduler', () => {
     });
   });
 
-  // ── clear / processOverlays ───────────────────────────────────
+  // ── clear ───────────────────────────────────
 
   describe('clear', () => {
     it('removes all overlays', () => {
@@ -228,14 +235,4 @@ describe('OverlayScheduler', () => {
       expect(scheduler.overlays).toHaveLength(0);
     });
   });
-
-  describe('processOverlays', () => {
-    it('sets overlays and returns layouts unchanged', () => {
-      const layouts = [{ id: 1 }, { id: 2 }];
-      const overlays = [makeOverlay({ file: 10 })];
-      const result = scheduler.processOverlays(layouts, overlays);
-      expect(result).toBe(layouts);
-      expect(scheduler.overlays).toHaveLength(1);
-    });
-  });
 });

package/src/schedule.js

@@ -6,7 +6,7 @@
 
 import { createLogger } from '@xiboplayer/utils';
 import { evaluateCriteria } from './criteria.js';
-import { buildScheduleQueue, parseLayoutFile } from './timeline.js';
+import { buildScheduleQueue, canSimulatedPlay, parseLayoutFile } from './timeline.js';
 
 const log = createLogger('Schedule');
 
@@ -531,41 +531,8 @@ export class ScheduleManager {
    * @returns {boolean} True if layout can play, false if exceeded limit
    */
   canPlayLayout(layoutId, maxPlaysPerHour) {
-    // If maxPlaysPerHour is 0 or undefined, unlimited plays
-    if (!maxPlaysPerHour || maxPlaysPerHour === 0) {
-      return true;
-    }
-
-    const now = Date.now();
-    const oneHourAgo = now - (60 * 60 * 1000);
-
-    // Get play history for this layout
     const history = this.playHistory.get(layoutId) || [];
-
-    // Filter to plays within the last hour
-    const playsInLastHour = history.filter(timestamp => timestamp > oneHourAgo);
-
-    // Check 1: Total plays in last hour must be under limit
-    if (playsInLastHour.length >= maxPlaysPerHour) {
-      log.info(`Layout ${layoutId} has reached max plays per hour (${playsInLastHour.length}/${maxPlaysPerHour})`);
-      return false;
-    }
-
-    // Check 2: Minimum gap between plays for even distribution
-    // e.g., 3/hour → 1 every 20 min, 6/hour → 1 every 10 min
-    if (playsInLastHour.length > 0) {
-      const minGapMs = (60 * 60 * 1000) / maxPlaysPerHour;
-      const lastPlayTime = Math.max(...playsInLastHour);
-      const elapsed = now - lastPlayTime;
-
-      if (elapsed < minGapMs) {
-        const remainingMin = ((minGapMs - elapsed) / 60000).toFixed(1);
-        log.info(`Layout ${layoutId} spacing: next play in ${remainingMin} min (${playsInLastHour.length}/${maxPlaysPerHour} plays, ${Math.round(minGapMs/60000)} min gap)`);
-        return false;
-      }
-    }
-
-    return true;
+    return canSimulatedPlay(history, maxPlaysPerHour, Date.now());
   }
 
   /**
@@ -588,15 +555,6 @@ export class ScheduleManager {
     log.info(`Recorded play for layout ${layoutId} (${cleaned.length} plays in last hour)`);
   }
 
-  /**
-   * Get the max priority of any time-active layout (ignoring rate-limit filtering).
-   * Returns 0 if no layouts are active or if getCurrentLayouts() hasn't been called.
-   * @returns {number}
-   */
-  getMaxActivePriority() {
-    return this._maxActivePriority || 0;
-  }
-
   /**
    * Check if a layout file is a sync event (part of multi-display sync group)
    * @param {string} layoutFile - Layout file identifier (e.g., '123')
@@ -736,6 +694,14 @@ export class ScheduleManager {
     return queue[(this._queuePosition + 1) % queue.length];
   }
 
+  /**
+   * Public API to invalidate the cached schedule queue.
+   * Called by PlayerCore when layout durations are corrected at runtime.
+   */
+  invalidateQueue() {
+    this._invalidateQueue();
+  }
+
   /**
    * Invalidate the cached queue (called on schedule change, time boundaries, etc.)
    */

package/src/timeline.js

@@ -112,7 +112,7 @@ function arraysEqual(a, b) {
  * @param {number} timeMs - Current simulated time in ms
  * @returns {boolean}
  */
-function canSimulatedPlay(history, maxPlaysPerHour, timeMs) {
+export function canSimulatedPlay(history, maxPlaysPerHour, timeMs) {
   if (!maxPlaysPerHour || maxPlaysPerHour === 0) return true;
 
   const oneHourAgo = timeMs - 3600000;