@xiboplayer/core 0.1.0

package/src/state.js

@@ -0,0 +1,54 @@
+/**
+ * Centralized player state
+ *
+ * Single source of truth for player status, dimensions, and display info.
+ * Avoids scattered state across PlayerCore, renderer, and platform layer.
+ */
+
+import { EventEmitter } from '@xiboplayer/utils';
+
+export class PlayerState extends EventEmitter {
+  constructor() {
+    super();
+    this.currentLayoutId = null;
+    this.currentScheduleId = null;
+    this.displayName = '';
+    this.hardwareKey = '';
+    this.playerType = 'pwa';
+    this.displayStatus = 'idle'; // idle | collecting | rendering | error
+    this.screenWidth = 0;
+    this.screenHeight = 0;
+    this.lastCollectionTime = null;
+    this.lastHeartbeat = null;
+    this.isRegistered = false;
+  }
+
+  /**
+   * Update a state property and emit change event
+   */
+  set(key, value) {
+    if (this[key] === value) return;
+    const old = this[key];
+    this[key] = value;
+    this.emit('change', key, value, old);
+  }
+
+  /**
+   * Get snapshot of current state (for status reporting)
+   */
+  toJSON() {
+    return {
+      currentLayoutId: this.currentLayoutId,
+      currentScheduleId: this.currentScheduleId,
+      displayName: this.displayName,
+      hardwareKey: this.hardwareKey,
+      playerType: this.playerType,
+      displayStatus: this.displayStatus,
+      screenWidth: this.screenWidth,
+      screenHeight: this.screenHeight,
+      lastCollectionTime: this.lastCollectionTime,
+      lastHeartbeat: this.lastHeartbeat,
+      isRegistered: this.isRegistered
+    };
+  }
+}

package/src/state.test.js

@@ -0,0 +1,206 @@
+/**
+ * PlayerState Tests
+ *
+ * Tests for centralized player state management
+ */
+
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { PlayerState } from './state.js';
+
+describe('PlayerState', () => {
+  let state;
+
+  beforeEach(() => {
+    state = new PlayerState();
+  });
+
+  describe('Initial State', () => {
+    it('should start with null currentLayoutId', () => {
+      expect(state.currentLayoutId).toBeNull();
+    });
+
+    it('should start with null currentScheduleId', () => {
+      expect(state.currentScheduleId).toBeNull();
+    });
+
+    it('should start with empty displayName', () => {
+      expect(state.displayName).toBe('');
+    });
+
+    it('should start with empty hardwareKey', () => {
+      expect(state.hardwareKey).toBe('');
+    });
+
+    it('should start with pwa playerType', () => {
+      expect(state.playerType).toBe('pwa');
+    });
+
+    it('should start with idle displayStatus', () => {
+      expect(state.displayStatus).toBe('idle');
+    });
+
+    it('should start with zero screen dimensions', () => {
+      expect(state.screenWidth).toBe(0);
+      expect(state.screenHeight).toBe(0);
+    });
+
+    it('should start with null lastCollectionTime', () => {
+      expect(state.lastCollectionTime).toBeNull();
+    });
+
+    it('should start with null lastHeartbeat', () => {
+      expect(state.lastHeartbeat).toBeNull();
+    });
+
+    it('should start with isRegistered false', () => {
+      expect(state.isRegistered).toBe(false);
+    });
+  });
+
+  describe('set()', () => {
+    it('should update a property value', () => {
+      state.set('displayName', 'Test Display');
+
+      expect(state.displayName).toBe('Test Display');
+    });
+
+    it('should emit change event with key, new value, and old value', () => {
+      const spy = vi.fn();
+      state.on('change', spy);
+
+      state.set('displayStatus', 'rendering');
+
+      expect(spy).toHaveBeenCalledTimes(1);
+      expect(spy).toHaveBeenCalledWith('displayStatus', 'rendering', 'idle');
+    });
+
+    it('should not emit change event when value is the same', () => {
+      const spy = vi.fn();
+      state.on('change', spy);
+
+      state.set('playerType', 'pwa'); // Same as initial value
+
+      expect(spy).not.toHaveBeenCalled();
+    });
+
+    it('should not emit change event for same null value', () => {
+      const spy = vi.fn();
+      state.on('change', spy);
+
+      state.set('currentLayoutId', null); // Same as initial value
+
+      expect(spy).not.toHaveBeenCalled();
+    });
+
+    it('should emit change event when changing from null to a value', () => {
+      const spy = vi.fn();
+      state.on('change', spy);
+
+      state.set('currentLayoutId', 42);
+
+      expect(spy).toHaveBeenCalledWith('currentLayoutId', 42, null);
+    });
+
+    it('should emit change event when changing from a value to null', () => {
+      state.set('currentLayoutId', 42);
+
+      const spy = vi.fn();
+      state.on('change', spy);
+
+      state.set('currentLayoutId', null);
+
+      expect(spy).toHaveBeenCalledWith('currentLayoutId', null, 42);
+    });
+
+    it('should handle multiple sequential updates', () => {
+      const spy = vi.fn();
+      state.on('change', spy);
+
+      state.set('displayStatus', 'collecting');
+      state.set('displayStatus', 'rendering');
+      state.set('displayStatus', 'idle');
+
+      expect(spy).toHaveBeenCalledTimes(3);
+      expect(spy).toHaveBeenNthCalledWith(1, 'displayStatus', 'collecting', 'idle');
+      expect(spy).toHaveBeenNthCalledWith(2, 'displayStatus', 'rendering', 'collecting');
+      expect(spy).toHaveBeenNthCalledWith(3, 'displayStatus', 'idle', 'rendering');
+    });
+
+    it('should update numeric properties', () => {
+      state.set('screenWidth', 1920);
+      state.set('screenHeight', 1080);
+
+      expect(state.screenWidth).toBe(1920);
+      expect(state.screenHeight).toBe(1080);
+    });
+
+    it('should update boolean properties', () => {
+      const spy = vi.fn();
+      state.on('change', spy);
+
+      state.set('isRegistered', true);
+
+      expect(state.isRegistered).toBe(true);
+      expect(spy).toHaveBeenCalledWith('isRegistered', true, false);
+    });
+
+    it('should not emit when setting same boolean value', () => {
+      const spy = vi.fn();
+      state.on('change', spy);
+
+      state.set('isRegistered', false); // Same as initial
+
+      expect(spy).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('toJSON()', () => {
+    it('should return a snapshot of all state properties', () => {
+      const json = state.toJSON();
+
+      expect(json).toEqual({
+        currentLayoutId: null,
+        currentScheduleId: null,
+        displayName: '',
+        hardwareKey: '',
+        playerType: 'pwa',
+        displayStatus: 'idle',
+        screenWidth: 0,
+        screenHeight: 0,
+        lastCollectionTime: null,
+        lastHeartbeat: null,
+        isRegistered: false
+      });
+    });
+
+    it('should reflect updated values', () => {
+      state.set('displayName', 'My Display');
+      state.set('currentLayoutId', 123);
+      state.set('isRegistered', true);
+      state.set('screenWidth', 1920);
+      state.set('screenHeight', 1080);
+
+      const json = state.toJSON();
+
+      expect(json.displayName).toBe('My Display');
+      expect(json.currentLayoutId).toBe(123);
+      expect(json.isRegistered).toBe(true);
+      expect(json.screenWidth).toBe(1920);
+      expect(json.screenHeight).toBe(1080);
+    });
+
+    it('should return a plain object (not the state instance)', () => {
+      const json = state.toJSON();
+
+      expect(json).not.toBe(state);
+      expect(json.constructor).toBe(Object);
+    });
+
+    it('should return independent snapshot (mutations do not affect original)', () => {
+      const json = state.toJSON();
+      json.displayName = 'Modified';
+
+      expect(state.displayName).toBe(''); // Original unchanged
+    });
+  });
+});

package/src/test-utils.js

@@ -0,0 +1,217 @@
+/**
+ * Test Utilities for Xibo Player Core
+ *
+ * Provides mocking utilities, test helpers, and fixtures for unit tests.
+ */
+
+import { vi } from 'vitest';
+
+/**
+ * Mock fetch with controllable responses
+ *
+ * Usage:
+ *   mockFetch({
+ *     'http://example.com/file.mp4': {
+ *       blob: createTestBlob(1024),
+ *       headers: { 'Content-Length': '1024' }
+ *     }
+ *   });
+ */
+export function mockFetch(responses = {}) {
+  global.fetch = vi.fn((url, options) => {
+    const method = options?.method || 'GET';
+    const key = `${method} ${url}`;
+    const response = responses[key] || responses[url];
+
+    if (!response) {
+      return Promise.resolve({
+        ok: false,
+        status: 404,
+        statusText: 'Not Found',
+        headers: {
+          get: () => null
+        }
+      });
+    }
+
+    return Promise.resolve({
+      ok: response.ok !== false,
+      status: response.status || 200,
+      statusText: response.statusText || 'OK',
+      headers: {
+        get: (name) => response.headers?.[name] || null
+      },
+      blob: () => Promise.resolve(response.blob || new Blob()),
+      text: () => Promise.resolve(response.text || ''),
+      json: () => Promise.resolve(response.json || {}),
+      arrayBuffer: () => Promise.resolve(response.arrayBuffer || new ArrayBuffer(0))
+    });
+  });
+
+  return global.fetch;
+}
+
+/**
+ * Mock Service Worker navigator
+ *
+ * Usage:
+ *   mockServiceWorker({ ready: true, controller: {} });
+ *   mockServiceWorker({ supported: false }); // Simulate no SW support
+ */
+export function mockServiceWorker(config = {}) {
+  const {
+    ready = true,
+    controller = {},
+    supported = true
+  } = config;
+
+  if (supported) {
+    global.navigator.serviceWorker = {
+      ready: ready ? Promise.resolve({ active: {} }) : Promise.reject(new Error('Not ready')),
+      controller: controller,
+      register: vi.fn(() => Promise.resolve({ scope: '/' })),
+      addEventListener: vi.fn(),
+      removeEventListener: vi.fn()
+    };
+  } else {
+    delete global.navigator.serviceWorker;
+  }
+}
+
+/**
+ * Mock CacheManager for DirectCacheBackend tests
+ *
+ * Returns a mock object with all cache.js methods
+ */
+export function mockCacheManager() {
+  return {
+    init: vi.fn(() => Promise.resolve()),
+    getCachedFile: vi.fn(() => Promise.resolve(null)),
+    getCachedResponse: vi.fn(() => Promise.resolve(null)),
+    downloadFile: vi.fn(() => Promise.resolve({ id: '1', size: 100 })),
+    getFile: vi.fn(() => Promise.resolve(null)),
+    getCacheKey: vi.fn((type, id) => `/cache/${type}/${id}`),
+    cache: {
+      match: vi.fn(() => Promise.resolve(null)),
+      put: vi.fn(() => Promise.resolve()),
+      delete: vi.fn(() => Promise.resolve(true))
+    }
+  };
+}
+
+/**
+ * Create test blob
+ *
+ * Usage:
+ *   const blob = createTestBlob(1024); // 1KB blob
+ *   const blob = createTestBlob(1024, 'video/mp4'); // Typed blob
+ */
+export function createTestBlob(size = 1024, type = 'application/octet-stream') {
+  const buffer = new ArrayBuffer(size);
+  return new Blob([buffer], { type });
+}
+
+/**
+ * Wait for condition to be true
+ *
+ * Usage:
+ *   await waitFor(() => task.state === 'complete', 5000);
+ */
+export async function waitFor(condition, timeout = 5000) {
+  const start = Date.now();
+  while (!condition()) {
+    if (Date.now() - start > timeout) {
+      throw new Error('waitFor timeout');
+    }
+    await new Promise(resolve => setTimeout(resolve, 50));
+  }
+}
+
+/**
+ * Wait for a specific time (for testing timing-dependent logic)
+ *
+ * Usage:
+ *   await wait(100); // Wait 100ms
+ */
+export async function wait(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+/**
+ * Create a spy that tracks calls but doesn't interfere
+ *
+ * Usage:
+ *   const spy = createSpy();
+ *   obj.on('event', spy);
+ *   // ... trigger event
+ *   expect(spy).toHaveBeenCalledWith('arg1', 'arg2');
+ */
+export function createSpy() {
+  return vi.fn();
+}
+
+/**
+ * Mock MessageChannel for Service Worker tests
+ */
+export function mockMessageChannel() {
+  class MockMessagePort {
+    constructor() {
+      this.onmessage = null;
+      this._listeners = [];
+    }
+
+    addEventListener(event, callback) {
+      if (event === 'message') {
+        this._listeners.push(callback);
+      }
+    }
+
+    removeEventListener(event, callback) {
+      if (event === 'message') {
+        const index = this._listeners.indexOf(callback);
+        if (index !== -1) {
+          this._listeners.splice(index, 1);
+        }
+      }
+    }
+
+    postMessage(data) {
+      // Simulate async message passing
+      setTimeout(() => {
+        if (this.paired) {
+          const event = { data };
+
+          // Call onmessage if set
+          if (this.paired.onmessage) {
+            this.paired.onmessage(event);
+          }
+
+          // Call event listeners
+          this.paired._listeners.forEach(listener => listener(event));
+        }
+      }, 0);
+    }
+  }
+
+  class MockMessageChannel {
+    constructor() {
+      this.port1 = new MockMessagePort();
+      this.port2 = new MockMessagePort();
+      this.port1.paired = this.port2;
+      this.port2.paired = this.port1;
+    }
+  }
+
+  global.MessageChannel = MockMessageChannel;
+  return MockMessageChannel;
+}
+
+/**
+ * Reset all mocks
+ */
+export function resetMocks() {
+  vi.clearAllMocks();
+  delete global.fetch;
+  delete global.navigator.serviceWorker;
+  delete global.MessageChannel;
+}

package/src/xmds-test.html

@@ -0,0 +1,109 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="utf-8">
+  <title>XMDS Campaign Parsing Tests</title>
+  <style>
+    body {
+      font-family: monospace;
+      padding: 20px;
+      background: #1e1e1e;
+      color: #d4d4d4;
+    }
+    .pass { color: #4ec9b0; }
+    .fail { color: #f48771; }
+    pre { background: #2d2d2d; padding: 10px; border-left: 3px solid #4ec9b0; }
+  </style>
+</head>
+<body>
+  <h1>XMDS Campaign Parsing Tests</h1>
+  <div id="output"></div>
+
+  <script type="module">
+    import { XmdsClient } from './xmds.js';
+
+    const output = document.getElementById('output');
+
+    function log(msg, isPass = true) {
+      const div = document.createElement('div');
+      div.className = isPass ? 'pass' : 'fail';
+      div.textContent = msg;
+      output.appendChild(div);
+    }
+
+    // Test XML with campaigns
+    const scheduleXmlWithCampaigns = `
+<schedule>
+  <default file="0"/>
+
+  <!-- Campaign with 3 layouts -->
+  <campaign id="5" priority="10" fromdt="2026-01-30 00:00:00" todt="2026-01-31 23:59:59" scheduleid="15">
+    <layout file="100"/>
+    <layout file="101"/>
+    <layout file="102"/>
+  </campaign>
+
+  <!-- Standalone layout -->
+  <layout file="200" priority="5" fromdt="2026-01-30 00:00:00" todt="2026-01-31 23:59:59" scheduleid="20"/>
+
+  <!-- Another campaign with 2 layouts -->
+  <campaign id="6" priority="8" fromdt="2026-01-30 00:00:00" todt="2026-01-31 23:59:59" scheduleid="25">
+    <layout file="300"/>
+    <layout file="301"/>
+  </campaign>
+</schedule>
+`;
+
+    // Test XML with only standalone layouts (backward compatibility)
+    const scheduleXmlStandalone = `
+<schedule>
+  <default file="0"/>
+  <layout file="100" priority="10" fromdt="2026-01-30 00:00:00" todt="2026-01-31 23:59:59" scheduleid="10"/>
+  <layout file="101" priority="5" fromdt="2026-01-30 00:00:00" todt="2026-01-31 23:59:59" scheduleid="11"/>
+</schedule>
+`;
+
+    function testParseScheduleWithCampaigns() {
+      const client = new XmdsClient({ cmsAddress: 'http://test', cmsKey: 'key', hardwareKey: 'hw' });
+      const schedule = client.parseScheduleResponse(scheduleXmlWithCampaigns);
+
+      console.log('Parsed schedule:', schedule);
+
+      console.assert(schedule.default === '0', 'Default should be 0');
+      console.assert(schedule.campaigns.length === 2, 'Should have 2 campaigns');
+
+      const campaign1 = schedule.campaigns[0];
+      console.assert(campaign1.id === '5', 'Campaign 1 ID should be 5');
+      console.assert(campaign1.priority === 10, 'Campaign 1 priority should be 10');
+      console.assert(campaign1.layouts.length === 3, 'Campaign 1 should have 3 layouts');
+      console.assert(campaign1.layouts[0].file === '100', 'Campaign 1 layout 1 file should be 100');
+
+      console.assert(schedule.layouts.length === 1, 'Should have 1 standalone layout');
+      console.assert(schedule.layouts[0].file === '200', 'Standalone layout file should be 200');
+
+      log('✓ Test 1 passed: Parse schedule with campaigns');
+    }
+
+    function testParseScheduleStandalone() {
+      const client = new XmdsClient({ cmsAddress: 'http://test', cmsKey: 'key', hardwareKey: 'hw' });
+      const schedule = client.parseScheduleResponse(scheduleXmlStandalone);
+
+      console.assert(schedule.campaigns.length === 0, 'Should have 0 campaigns');
+      console.assert(schedule.layouts.length === 2, 'Should have 2 standalone layouts');
+
+      log('✓ Test 2 passed: Parse schedule with standalone layouts (backward compatible)');
+    }
+
+    // Run tests
+    log('\n=== Running XMDS Campaign Parsing Tests ===\n');
+    try {
+      testParseScheduleWithCampaigns();
+      testParseScheduleStandalone();
+      log('\n=== All XMDS tests passed! ===\n');
+    } catch (e) {
+      log('✗ Test failed: ' + e.message, false);
+      console.error(e);
+    }
+  </script>
+</body>
+</html>