@xiboplayer/schedule 0.4.0 → 0.4.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xiboplayer/schedule",
-  "version": "0.4.0",
+  "version": "0.4.3",
   "description": "Complete scheduling solution: campaigns, dayparting, interrupts, and overlays",
   "type": "module",
   "main": "./src/index.js",
@@ -11,7 +11,7 @@
     "./overlays": "./src/overlays.js"
   },
   "dependencies": {
-    "@xiboplayer/utils": "0.4.0"
+    "@xiboplayer/utils": "0.4.3"
   },
   "devDependencies": {
     "vitest": "^2.0.0"

package/src/schedule.js

@@ -41,6 +41,36 @@ export class ScheduleManager {
     return this.schedule?.dataConnectors || [];
   }
 
+  /**
+   * Get dependants map: layoutId → filenames that must be cached before that layout plays.
+   * Includes both per-layout and global dependants.
+   * Used by download manager to prioritize sub-playlist media alongside its parent layout.
+   * @returns {Map<number, string[]>} layoutId → dependant filenames
+   */
+  getDependantsMap() {
+    const map = new Map();
+    if (!this.schedule) return map;
+
+    const globalDeps = this.schedule.dependants || [];
+
+    const addLayout = (layout) => {
+      const id = parseInt(String(layout.file || layout.id).replace('.xlf', ''), 10);
+      const deps = [...globalDeps, ...(layout.dependants || [])];
+      if (deps.length > 0) map.set(id, deps);
+    };
+
+    if (this.schedule.layouts) {
+      for (const layout of this.schedule.layouts) addLayout(layout);
+    }
+    if (this.schedule.campaigns) {
+      for (const campaign of this.schedule.campaigns) {
+        for (const layout of campaign.layouts) addLayout(layout);
+      }
+    }
+
+    return map;
+  }
+
   /**
    * Check if a schedule item is active based on recurrence rules.
    * Supports Week, Day, and Month recurrence types.

package/src/schedule.test.js

@@ -707,4 +707,74 @@ describe('ScheduleManager - Actions and Commands', () => {
       expect(windowMs).toBeGreaterThanOrEqual(60 * 60 * 1000); // at least 1 hour
     });
   });
+
+  describe('getDependantsMap', () => {
+    it('should return empty map when no schedule', () => {
+      const map = manager.getDependantsMap();
+      expect(map.size).toBe(0);
+    });
+
+    it('should collect per-layout dependants from standalone layouts', () => {
+      manager.setSchedule({
+        layouts: [
+          { file: '472.xlf', dependants: ['11.pdf', 'video.mp4'] },
+          { file: '500.xlf', dependants: ['logo.png'] },
+        ],
+        campaigns: [],
+      });
+      const map = manager.getDependantsMap();
+      expect(map.get(472)).toEqual(['11.pdf', 'video.mp4']);
+      expect(map.get(500)).toEqual(['logo.png']);
+    });
+
+    it('should collect per-layout dependants from campaign layouts', () => {
+      manager.setSchedule({
+        layouts: [],
+        campaigns: [
+          {
+            id: 'c1',
+            layouts: [
+              { file: '300.xlf', dependants: ['font.woff2'] },
+            ],
+          },
+        ],
+      });
+      const map = manager.getDependantsMap();
+      expect(map.get(300)).toEqual(['font.woff2']);
+    });
+
+    it('should merge global dependants with per-layout dependants', () => {
+      manager.setSchedule({
+        dependants: ['global-font.woff2'],
+        layouts: [
+          { file: '472.xlf', dependants: ['11.pdf'] },
+        ],
+        campaigns: [],
+      });
+      const map = manager.getDependantsMap();
+      expect(map.get(472)).toEqual(['global-font.woff2', '11.pdf']);
+    });
+
+    it('should skip layouts with no dependants', () => {
+      manager.setSchedule({
+        layouts: [
+          { file: '100.xlf', dependants: [] },
+          { file: '200.xlf', dependants: ['bg.jpg'] },
+        ],
+        campaigns: [],
+      });
+      const map = manager.getDependantsMap();
+      expect(map.has(100)).toBe(false);
+      expect(map.get(200)).toEqual(['bg.jpg']);
+    });
+
+    it('should handle file IDs without .xlf extension', () => {
+      manager.setSchedule({
+        layouts: [{ file: '472', dependants: ['11.pdf'] }],
+        campaigns: [],
+      });
+      const map = manager.getDependantsMap();
+      expect(map.get(472)).toEqual(['11.pdf']);
+    });
+  });
 });

package/src/timeline.js

@@ -153,6 +153,7 @@ function getPlayableLayouts(allLayouts, simPlays, timeMs) {
  * @param {Date}   [options.from]    - Start time (default: now)
  * @param {number} [options.hours]   - Hours to simulate (default: 2)
  * @param {number} [options.defaultDuration] - Fallback duration in seconds (default: 60)
+ * @param {Date}   [options.currentLayoutStartedAt] - When current layout started (adjusts first entry to remaining time)
  * @returns {Array<{layoutFile: string, startTime: Date, endTime: Date, duration: number, isDefault: boolean}>}
  */
 export function calculateTimeline(schedule, durations, options = {}) {
@@ -160,8 +161,10 @@ export function calculateTimeline(schedule, durations, options = {}) {
   const hours = options.hours || 2;
   const to = new Date(from.getTime() + hours * 3600000);
   const defaultDuration = options.defaultDuration || 60;
+  const currentLayoutStartedAt = options.currentLayoutStartedAt || null;
   const timeline = [];
   let currentTime = new Date(from);
+  let isFirstEntry = true;
 
   // Use getAllLayoutsAtTime if available (new API), fall back to getLayoutsAtTime (old API)
   const hasFullApi = typeof schedule.getAllLayoutsAtTime === 'function';
@@ -216,7 +219,16 @@ export function calculateTimeline(schedule, durations, options = {}) {
     // Round-robin through playable layouts
     for (let i = 0; i < playable.length && currentTime < to && timeline.length < maxEntries; i++) {
       const file = playable[i];
-      const dur = durations.get(file) || defaultDuration;
+      let dur = durations.get(file) || defaultDuration;
+
+      // First entry: use remaining duration if we know when the current layout started
+      if (isFirstEntry && currentLayoutStartedAt) {
+        const elapsedSec = (from.getTime() - currentLayoutStartedAt.getTime()) / 1000;
+        const remaining = Math.max(1, Math.round(dur - elapsedSec));
+        dur = remaining;
+        isFirstEntry = false;
+      }
+
       const endMs = currentTime.getTime() + dur * 1000;
 
       const entry = {