@xiboplayer/utils 0.6.13 → 0.7.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xiboplayer/utils",
-  "version": "0.6.13",
+  "version": "0.7.1",
   "description": "Shared utilities for Xibo Player packages",
   "type": "module",
   "main": "./src/index.js",
@@ -12,7 +12,7 @@
     "./config": "./src/config.js"
   },
   "dependencies": {
-    "@xiboplayer/crypto": "0.6.13"
+    "@xiboplayer/crypto": "0.7.1"
   },
   "devDependencies": {
     "vitest": "^2.0.0"

package/src/config.js

@@ -13,6 +13,7 @@
  * In browser (PWA player): localStorage is primary, env vars override if set.
  */
 import { generateRsaKeyPair, isValidPemKey } from '@xiboplayer/crypto';
+import { openIDB } from './idb.js';
 
 const GLOBAL_KEY = 'xibo_global';         // Device identity (all CMSes)
 const CMS_PREFIX = 'xibo_cms:';           // Per-CMS config prefix
@@ -351,26 +352,17 @@ export class Config {
    * IndexedDB survives "Clear site data" in some browsers where localStorage doesn't.
    * @param {Object} keys - Key-value pairs to store (e.g. { hardwareKey: '...', xmrPubKey: '...' })
    */
-  _backupKeys(keys) {
+  async _backupKeys(keys) {
     try {
-      const req = indexedDB.open(HW_DB_NAME, HW_DB_VERSION);
-      req.onupgradeneeded = () => {
-        const db = req.result;
-        if (!db.objectStoreNames.contains('keys')) {
-          db.createObjectStore('keys');
-        }
-      };
-      req.onsuccess = () => {
-        const db = req.result;
-        const tx = db.transaction('keys', 'readwrite');
-        const store = tx.objectStore('keys');
-        for (const [k, v] of Object.entries(keys)) {
-          store.put(v, k);
-        }
-        tx.oncomplete = () => {
-          console.log('[Config] Keys backed up to IndexedDB:', Object.keys(keys).join(', '));
-          db.close();
-        };
+      const db = await openIDB(HW_DB_NAME, HW_DB_VERSION, 'keys');
+      const tx = db.transaction('keys', 'readwrite');
+      const store = tx.objectStore('keys');
+      for (const [k, v] of Object.entries(keys)) {
+        store.put(v, k);
+      }
+      tx.oncomplete = () => {
+        console.log('[Config] Keys backed up to IndexedDB:', Object.keys(keys).join(', '));
+        db.close();
       };
     } catch (e) {
       // IndexedDB not available — localStorage-only mode
@@ -390,19 +382,8 @@ export class Config {
    * differs from the current one, it restores the original key.
    */
   async _restoreHardwareKeyFromBackup() {
-    if (typeof indexedDB === 'undefined') return;
     try {
-      const db = await new Promise((resolve, reject) => {
-        const req = indexedDB.open(HW_DB_NAME, HW_DB_VERSION);
-        req.onupgradeneeded = () => {
-          const db = req.result;
-          if (!db.objectStoreNames.contains('keys')) {
-            db.createObjectStore('keys');
-          }
-        };
-        req.onsuccess = () => resolve(req.result);
-        req.onerror = () => reject(req.error);
-      });
+      const db = await openIDB(HW_DB_NAME, HW_DB_VERSION, 'keys');
 
       const tx = db.transaction('keys', 'readonly');
       const store = tx.objectStore('keys');
@@ -450,32 +431,6 @@ export class Config {
     return hardwareKey;
   }
 
-  getCanvasFingerprint() {
-    // Generate stable canvas fingerprint (same for same GPU/driver)
-    try {
-      const canvas = document.createElement('canvas');
-      const ctx = canvas.getContext('2d');
-      if (!ctx) return 'no-canvas';
-
-      // Draw test pattern (same rendering = same device)
-      ctx.textBaseline = 'top';
-      ctx.font = '14px Arial';
-      ctx.fillStyle = '#f60';
-      ctx.fillRect(125, 1, 62, 20);
-      ctx.fillStyle = '#069';
-      ctx.fillText('Xibo Player', 2, 15);
-
-      return canvas.toDataURL();
-    } catch (e) {
-      return 'canvas-error';
-    }
-  }
-
-  generateHardwareKey() {
-    // For backwards compatibility
-    return this.generateStableHardwareKey();
-  }
-
   generateXmrChannel() {
     // Generate UUID for XMR channel
     return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
@@ -510,34 +465,6 @@ export class Config {
     console.log('[Config] RSA key pair generated and saved');
   }
 
-  hash(str) {
-    // FNV-1a hash algorithm (better distribution than simple hash)
-    // Produces high-entropy 32-character hex string
-    let hash = 2166136261; // FNV offset basis
-
-    for (let i = 0; i < str.length; i++) {
-      hash ^= str.charCodeAt(i);
-      hash += (hash << 1) + (hash << 4) + (hash << 7) + (hash << 8) + (hash << 24);
-    }
-
-    // Convert to unsigned 32-bit integer
-    hash = hash >>> 0;
-
-    // Extend to 32 characters by hashing multiple times with different seeds
-    let result = '';
-    for (let round = 0; round < 4; round++) {
-      let roundHash = hash + round * 1234567;
-      for (let i = 0; i < str.length; i++) {
-        roundHash ^= str.charCodeAt(i) + round;
-        roundHash += (roundHash << 1) + (roundHash << 4) + (roundHash << 7) + (roundHash << 8) + (roundHash << 24);
-      }
-      roundHash = roundHash >>> 0;
-      result += roundHash.toString(16).padStart(8, '0');
-    }
-
-    return result.substring(0, 32);
-  }
-
   get cmsUrl() { return this.data.cmsUrl; }
   set cmsUrl(val) { this.data.cmsUrl = val; this.save(); }
 

package/src/config.test.js

@@ -224,106 +224,6 @@ describe('Config', () => {
     });
   });
 
-  describe('Hash Function (FNV-1a)', () => {
-    beforeEach(() => {
-      config = new Config();
-    });
-
-    it('should generate 32-character hex hash', () => {
-      const hash = config.hash('test string');
-
-      expect(hash).toMatch(/^[0-9a-f]{32}$/);
-    });
-
-    it('should be deterministic for same input', () => {
-      const hash1 = config.hash('test');
-      const hash2 = config.hash('test');
-
-      expect(hash1).toBe(hash2);
-    });
-
-    it('should produce different hashes for different inputs', () => {
-      const hash1 = config.hash('test1');
-      const hash2 = config.hash('test2');
-
-      expect(hash1).not.toBe(hash2);
-    });
-
-    it('should handle empty string', () => {
-      const hash = config.hash('');
-
-      expect(hash).toMatch(/^[0-9a-f]{32}$/);
-    });
-
-    it('should produce good entropy for similar inputs', () => {
-      const hash1 = config.hash('a');
-      const hash2 = config.hash('b');
-
-      // Hashes should be completely different (not just 1 character difference)
-      let differences = 0;
-      for (let i = 0; i < hash1.length; i++) {
-        if (hash1[i] !== hash2[i]) differences++;
-      }
-
-      expect(differences).toBeGreaterThan(15); // At least half different
-    });
-  });
-
-  describe('Canvas Fingerprint', () => {
-    let createElementSpy;
-
-    beforeEach(() => {
-      config = new Config();
-
-      // Mock canvas via spying on document.createElement
-      const mockCanvas = {
-        getContext: vi.fn(() => ({
-          textBaseline: '',
-          font: '',
-          fillStyle: '',
-          fillRect: vi.fn(),
-          fillText: vi.fn()
-        })),
-        toDataURL: vi.fn(() => 'data:image/png;base64,mockdata')
-      };
-
-      createElementSpy = vi.spyOn(document, 'createElement').mockReturnValue(mockCanvas);
-    });
-
-    afterEach(() => {
-      createElementSpy.mockRestore();
-    });
-
-    it('should generate canvas fingerprint', () => {
-      const fingerprint = config.getCanvasFingerprint();
-
-      expect(fingerprint).toBe('data:image/png;base64,mockdata');
-      expect(createElementSpy).toHaveBeenCalledWith('canvas');
-    });
-
-    it('should return "no-canvas" when canvas context unavailable', () => {
-      const mockCanvas = {
-        getContext: vi.fn(() => null)
-      };
-
-      createElementSpy.mockReturnValue(mockCanvas);
-
-      const fingerprint = config.getCanvasFingerprint();
-
-      expect(fingerprint).toBe('no-canvas');
-    });
-
-    it('should return "canvas-error" on exception', () => {
-      createElementSpy.mockImplementation(() => {
-        throw new Error('Canvas not supported');
-      });
-
-      const fingerprint = config.getCanvasFingerprint();
-
-      expect(fingerprint).toBe('canvas-error');
-    });
-  });
-
   describe('Configuration Getters/Setters', () => {
     beforeEach(() => {
       config = new Config();
@@ -436,20 +336,6 @@ describe('Config', () => {
     });
   });
 
-  describe('Backwards Compatibility', () => {
-    beforeEach(() => {
-      config = new Config();
-    });
-
-    it('should support generateHardwareKey() alias', () => {
-      const key1 = config.generateHardwareKey();
-      const key2 = config.generateStableHardwareKey();
-
-      // Both should generate valid keys
-      expect(key1).toMatch(/^pwa-[0-9a-f]{28}$/);
-      expect(key2).toMatch(/^pwa-[0-9a-f]{28}$/);
-    });
-  });
 
   describe('Edge Cases', () => {
     it('should handle missing hardwareKey in loaded config', () => {
@@ -482,22 +368,6 @@ describe('Config', () => {
       expect(config.cmsUrl).toBe('');
     });
 
-    it('should handle very long strings', () => {
-      config = new Config();
-
-      const longString = 'a'.repeat(10000);
-      const hash = config.hash(longString);
-
-      expect(hash).toMatch(/^[0-9a-f]{32}$/);
-    });
-
-    it('should handle unicode in hash', () => {
-      config = new Config();
-
-      const hash = config.hash('测试中文🎉');
-
-      expect(hash).toMatch(/^[0-9a-f]{32}$/);
-    });
   });
 
   describe('Persistence', () => {

package/src/idb.js

@@ -0,0 +1,37 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// Copyright (c) 2024-2026 Pau Aliagas <linuxnow@gmail.com>
+/**
+ * Shared IndexedDB open helper — avoids duplicating the open/upgrade
+ * boilerplate across stats, core, and config packages.
+ *
+ * @param {string} dbName - Database name
+ * @param {number} version - Schema version
+ * @param {string} storeName - Object store to create on upgrade
+ * @param {Object} [options]
+ * @param {string} [options.keyPath] - Key path for the store (auto-increment if set)
+ * @param {string} [options.indexName] - Index to create on the store
+ * @param {string} [options.indexKey] - Key for the index
+ * @returns {Promise<IDBDatabase>}
+ */
+export function openIDB(dbName, version, storeName, options = {}) {
+  if (typeof indexedDB === 'undefined') {
+    return Promise.reject(new Error('IndexedDB not available'));
+  }
+  return new Promise((resolve, reject) => {
+    const req = indexedDB.open(dbName, version);
+    req.onupgradeneeded = () => {
+      const db = req.result;
+      if (!db.objectStoreNames.contains(storeName)) {
+        const storeOpts = options.keyPath
+          ? { keyPath: options.keyPath, autoIncrement: true }
+          : undefined;
+        const store = db.createObjectStore(storeName, storeOpts);
+        if (options.indexName && options.indexKey) {
+          store.createIndex(options.indexName, options.indexKey, { unique: false });
+        }
+      }
+    };
+    req.onsuccess = () => resolve(req.result);
+    req.onerror = () => reject(req.error);
+  });
+}

package/src/index.js

@@ -8,6 +8,7 @@ export { EventEmitter } from './event-emitter.js';
 import { config as _config } from './config.js';
 export { config, SHELL_ONLY_KEYS, extractPwaConfig, computeCmsId, fnvHash, warnPlatformMismatch } from './config.js';
 export { fetchWithRetry } from './fetch-retry.js';
+export { openIDB } from './idb.js';
 export { CmsApiClient, CmsApiError } from './cms-api.js';
 
 /**