@xiboplayer/renderer 0.6.1 → 0.6.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xiboplayer/renderer",
-  "version": "0.6.1",
+  "version": "0.6.3",
   "description": "RendererLite - Fast, efficient XLF layout rendering engine",
   "type": "module",
   "main": "./src/index.js",
@@ -13,8 +13,9 @@
   "dependencies": {
     "nanoevents": "^9.1.0",
     "pdfjs-dist": "^4.10.38",
-    "@xiboplayer/cache": "0.6.1",
-    "@xiboplayer/utils": "0.6.1"
+    "@xiboplayer/utils": "0.6.3",
+    "@xiboplayer/cache": "0.6.3",
+    "@xiboplayer/schedule": "0.6.3"
   },
   "devDependencies": {
     "vitest": "^2.0.0",

package/src/index.d.ts

@@ -6,7 +6,7 @@ export interface RendererConfig {
 }
 
 export interface RendererOptions {
-  getMediaUrl?: (fileId: number) => Promise<string>;
+  fileIdToSaveAs?: Map<string, string>;
   getWidgetHtml?: (widget: any) => Promise<string | { url: string; fallback?: string }>;
   logLevel?: string;
 }

package/src/layout-pool.test.js

@@ -33,8 +33,7 @@ describe('LayoutPool', () => {
       container,
       layout: { width: 1920, height: 1080, duration: 60, bgcolor: '#000', regions: [] },
       regions: new Map(),
-      blobUrls: new Set(),
-      mediaUrlCache: new Map()
+      blobUrls: new Set()
     };
   }
 
@@ -170,18 +169,6 @@ describe('LayoutPool', () => {
       expect(URL.revokeObjectURL).toHaveBeenCalledWith('blob:test-2');
     });
 
-    it('should revoke media blob URLs on eviction', () => {
-      const entry = createMockEntry(1);
-      entry.mediaUrlCache.set(10, 'blob:media-10');
-      entry.mediaUrlCache.set(20, 'blob:media-20');
-
-      pool.add(1, entry);
-      pool.evict(1);
-
-      expect(URL.revokeObjectURL).toHaveBeenCalledWith('blob:media-10');
-      expect(URL.revokeObjectURL).toHaveBeenCalledWith('blob:media-20');
-    });
-
     it('should remove container from DOM', () => {
       const entry = createMockEntry(1);
       pool.add(1, entry);

package/src/layout.js

@@ -303,10 +303,16 @@ window.Transitions = {
     const direction = transitionConfig.direction || 'N';
 
     switch (type) {
+      case 'fade':
+        return isIn ? this.fadeIn(element, duration) : this.fadeOut(element, duration);
       case 'fadein':
         return isIn ? this.fadeIn(element, duration) : null;
       case 'fadeout':
         return isIn ? null : this.fadeOut(element, duration);
+      case 'fly':
+        return isIn
+          ? this.flyIn(element, duration, direction, regionWidth, regionHeight)
+          : this.flyOut(element, duration, direction, regionWidth, regionHeight);
       case 'flyin':
         return isIn ? this.flyIn(element, duration, direction, regionWidth, regionHeight) : null;
       case 'flyout':

package/src/renderer-lite.ic.test.js

@@ -0,0 +1,203 @@
+/**
+ * RendererLite Interactive Control (XIC) Tests
+ *
+ * Tests for the XIC event handlers: interactiveTrigger, widgetExpire,
+ * widgetExtendDuration, widgetSetDuration.
+ */
+
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { RendererLite } from './renderer-lite.js';
+
+/**
+ * Create a minimal RendererLite instance with stubbed DOM and methods.
+ */
+function createRenderer() {
+  const container = document.createElement('div');
+  const renderer = new RendererLite(
+    { cmsUrl: 'http://localhost', hardwareKey: 'test' },
+    container,
+    { logLevel: 'silent' }
+  );
+
+  // Stub methods that touch DOM or async operations
+  renderer.renderWidget = vi.fn();
+  renderer.stopWidget = vi.fn();
+  renderer.checkLayoutComplete = vi.fn();
+  renderer._startRegionCycle = vi.fn();
+  renderer.navigateToWidget = vi.fn();
+
+  return renderer;
+}
+
+/**
+ * Populate renderer with a fake region containing widgets.
+ */
+function addRegion(renderer, regionId, widgets) {
+  renderer.regions.set(regionId, {
+    element: document.createElement('div'),
+    config: { id: regionId },
+    widgets,
+    currentIndex: 0,
+    timer: null,
+    width: 100,
+    height: 100,
+    complete: false,
+    isDrawer: false,
+    widgetElements: new Map()
+  });
+}
+
+describe('RendererLite XIC', () => {
+  let renderer;
+
+  beforeEach(() => {
+    renderer = createRenderer();
+    addRegion(renderer, 'region-1', [
+      { id: 'w1', type: 'text', duration: 10, options: {} },
+      { id: 'w2', type: 'image', duration: 20, options: {} },
+      { id: 'w3', type: 'video', duration: 30, options: {} }
+    ]);
+  });
+
+  describe('_findRegionByWidgetId', () => {
+    it('should find a widget in main regions', () => {
+      const result = renderer._findRegionByWidgetId('w2');
+      expect(result).not.toBeNull();
+      expect(result.regionId).toBe('region-1');
+      expect(result.widgetIndex).toBe(1);
+      expect(result.widget.id).toBe('w2');
+      expect(result.regionMap).toBe(renderer.regions);
+    });
+
+    it('should return null for unknown widget', () => {
+      const result = renderer._findRegionByWidgetId('w-unknown');
+      expect(result).toBeNull();
+    });
+
+    it('should find a widget in overlay regions', () => {
+      const overlayRegions = new Map();
+      overlayRegions.set('overlay-r1', {
+        element: document.createElement('div'),
+        config: { id: 'overlay-r1' },
+        widgets: [{ id: 'ow1', type: 'text', duration: 5, options: {} }],
+        currentIndex: 0,
+        timer: null,
+        width: 50,
+        height: 50,
+        complete: false,
+        isDrawer: false,
+        widgetElements: new Map()
+      });
+      renderer.activeOverlays.set(100, { regions: overlayRegions });
+
+      const result = renderer._findRegionByWidgetId('ow1');
+      expect(result).not.toBeNull();
+      expect(result.regionId).toBe('overlay-r1');
+      expect(result.widgetIndex).toBe(0);
+      expect(result.regionMap).toBe(overlayRegions);
+    });
+  });
+
+  describe('_handleInteractiveTrigger', () => {
+    it('should call navigateToWidget when target exists', () => {
+      renderer.emit('interactiveTrigger', { targetId: 'w2', triggerCode: 'btn1' });
+      expect(renderer.navigateToWidget).toHaveBeenCalledWith('w2');
+    });
+
+    it('should not call navigateToWidget when target is unknown', () => {
+      renderer.emit('interactiveTrigger', { targetId: 'w-missing', triggerCode: 'btn1' });
+      expect(renderer.navigateToWidget).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('_handleWidgetExpire', () => {
+    it('should clear timer, stop widget, and advance region', () => {
+      const region = renderer.regions.get('region-1');
+      region.timer = setTimeout(() => {}, 99999);
+      region.currentIndex = 0;
+
+      renderer.emit('widgetExpire', { widgetId: 'w1' });
+
+      expect(region.timer).toBeNull();
+      expect(renderer.stopWidget).toHaveBeenCalledWith('region-1', 0);
+      expect(renderer._startRegionCycle).toHaveBeenCalled();
+    });
+
+    it('should do nothing for unknown widget', () => {
+      renderer.emit('widgetExpire', { widgetId: 'w-missing' });
+      expect(renderer.stopWidget).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('_handleWidgetExtendDuration', () => {
+    it('should clear existing timer and re-arm with extended duration', () => {
+      vi.useFakeTimers();
+      const region = renderer.regions.get('region-1');
+      region.timer = setTimeout(() => {}, 99999);
+
+      renderer.emit('widgetExtendDuration', { widgetId: 'w1', duration: 15 });
+
+      // Timer should be re-armed (not null)
+      expect(region.timer).not.toBeNull();
+      // stopWidget should NOT have been called yet (timer hasn't fired)
+      expect(renderer.stopWidget).not.toHaveBeenCalled();
+
+      // Advance time to fire the new timer
+      vi.advanceTimersByTime(15000);
+      expect(renderer.stopWidget).toHaveBeenCalledWith('region-1', 0);
+
+      vi.useRealTimers();
+    });
+
+    it('should do nothing for unknown widget', () => {
+      renderer.emit('widgetExtendDuration', { widgetId: 'w-missing', duration: 10 });
+      expect(renderer.stopWidget).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('_handleWidgetSetDuration', () => {
+    it('should clear existing timer and set absolute duration', () => {
+      vi.useFakeTimers();
+      const region = renderer.regions.get('region-1');
+      region.timer = setTimeout(() => {}, 99999);
+
+      renderer.emit('widgetSetDuration', { widgetId: 'w2', duration: 5 });
+
+      expect(region.timer).not.toBeNull();
+      expect(renderer.stopWidget).not.toHaveBeenCalled();
+
+      vi.advanceTimersByTime(5000);
+      // w2 is at index 1, but the region's currentIndex determines what gets stopped
+      expect(renderer.stopWidget).toHaveBeenCalled();
+
+      vi.useRealTimers();
+    });
+
+    it('should do nothing for unknown widget', () => {
+      renderer.emit('widgetSetDuration', { widgetId: 'w-missing', duration: 10 });
+      expect(renderer.stopWidget).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('_advanceRegion', () => {
+    it('should increment currentIndex and call _startRegionCycle', () => {
+      const region = renderer.regions.get('region-1');
+      region.currentIndex = 0;
+
+      renderer._advanceRegion('region-1', renderer.regions);
+
+      expect(region.currentIndex).toBe(1);
+      expect(renderer._startRegionCycle).toHaveBeenCalled();
+    });
+
+    it('should wrap around at end of widget list', () => {
+      const region = renderer.regions.get('region-1');
+      region.currentIndex = 2; // last widget
+
+      renderer._advanceRegion('region-1', renderer.regions);
+
+      expect(region.currentIndex).toBe(0);
+      expect(renderer._startRegionCycle).toHaveBeenCalled();
+    });
+  });
+});