unified-video-framework 1.4.425 → 1.4.426

package/packages/web/src/drm/types/DRMTypes.ts

@@ -1,93 +0,0 @@
-/**
- * DRM Type Definitions
- * Core type definitions and enums for DRM functionality
- */
-
-import type { DRMConfig, DRMType } from '@unified-video/core';
-import { DRMType as DRMTypeEnum } from '@unified-video/core';
-
-// Extended DRM configuration for internal use
-export interface ExtendedDRMConfig extends DRMConfig {
-  // Provider-specific settings
-  provider?: 'bunny' | 'generic' | string;
-
-  // Library/Video IDs for Bunny.net
-  libraryId?: string;
-  videoId?: string;
-
-  // Advanced options
-  retryConfig?: {
-    maxRetries: number;
-    retryDelay: number;
-  };
-
-  // Debugging
-  debug?: boolean;
-}
-
-// Browser DRM capabilities
-export interface DRMCapabilities {
-  widevine: boolean;
-  fairplay: boolean;
-  playready: boolean;
-  supportedType: DRMType | null;
-}
-
-// License request/response types
-export interface LicenseRequest {
-  url: string;
-  method: 'POST' | 'GET';
-  headers: Record<string, string>;
-  body: ArrayBuffer | string;
-  responseType: 'arraybuffer' | 'text' | 'json';
-}
-
-export interface LicenseResponse {
-  license: ArrayBuffer;
-  metadata?: any;
-}
-
-// EME event types
-export interface EMEMessageEvent {
-  messageType: string;
-  message: ArrayBuffer;
-}
-
-// DRM initialization result
-export interface DRMInitResult {
-  success: boolean;
-  drmType: DRMType;
-  keySystem: string;
-  error?: DRMError;
-}
-
-// DRM-specific errors
-export interface DRMError {
-  code: DRMErrorCode;
-  message: string;
-  fatal: boolean;
-  details?: any;
-  systemError?: any;
-}
-
-export enum DRMErrorCode {
-  UNSUPPORTED_BROWSER = 'DRM_UNSUPPORTED_BROWSER',
-  CERTIFICATE_LOAD_FAILED = 'DRM_CERTIFICATE_LOAD_FAILED',
-  LICENSE_REQUEST_FAILED = 'DRM_LICENSE_REQUEST_FAILED',
-  KEY_SYSTEM_ACCESS_DENIED = 'DRM_KEY_SYSTEM_ACCESS_DENIED',
-  MEDIA_KEYS_CREATION_FAILED = 'DRM_MEDIA_KEYS_CREATION_FAILED',
-  SESSION_CREATION_FAILED = 'DRM_SESSION_CREATION_FAILED',
-  LICENSE_INVALID = 'DRM_LICENSE_INVALID',
-  CONFIGURATION_ERROR = 'DRM_CONFIGURATION_ERROR',
-  NETWORK_ERROR = 'DRM_NETWORK_ERROR',
-  SECURE_CONTEXT_REQUIRED = 'DRM_SECURE_CONTEXT_REQUIRED',
-  TIMEOUT = 'DRM_TIMEOUT',
-}
-
-// Key system mappings
-export const KEY_SYSTEMS: Record<DRMType, string[]> = {
-  [DRMTypeEnum.WIDEVINE]: ['com.widevine.alpha'],
-  [DRMTypeEnum.PLAYREADY]: ['com.microsoft.playready', 'com.microsoft.playready.recommendation'],
-  [DRMTypeEnum.FAIRPLAY]: ['com.apple.fps.1_0', 'com.apple.fps'],
-  [DRMTypeEnum.CLEARKEY]: ['webkit-org.w3.clearkey', 'org.w3.clearkey'],
-};

package/packages/web/src/drm/utils/BrowserDetector.ts

@@ -1,281 +0,0 @@
-/**
- * Browser DRM Detector
- * Detects browser capabilities and determines optimal DRM system
- */
-
-import type { DRMType } from '@unified-video/core';
-import { DRMCapabilities, KEY_SYSTEMS } from '../types/DRMTypes';
-import { DRMType as DRMTypeEnum } from '@unified-video/core';
-
-export class BrowserDetector {
-  private static instance: BrowserDetector;
-  private capabilities: DRMCapabilities | null = null;
-
-  private constructor() { }
-
-  static getInstance(): BrowserDetector {
-    if (!BrowserDetector.instance) {
-      BrowserDetector.instance = new BrowserDetector();
-    }
-    return BrowserDetector.instance;
-  }
-
-  /**
-   * Detect DRM capabilities of current browser
-   */
-  async detectCapabilities(): Promise<DRMCapabilities> {
-    if (this.capabilities) {
-      return this.capabilities;
-    }
-
-    const capabilities: DRMCapabilities = {
-      widevine: false,
-      fairplay: false,
-      playready: false,
-      supportedType: null,
-    };
-
-    // Check for FairPlay (Safari/iOS) - highest priority on Apple devices
-    if (this.isSafari() || this.isWebKitBased()) {
-      capabilities.fairplay = await this.checkFairPlaySupport();
-      if (capabilities.fairplay) {
-        capabilities.supportedType = DRMTypeEnum.FAIRPLAY;
-      }
-    }
-
-    // Check for Widevine (Chrome, Firefox, Edge)
-    if (!capabilities.supportedType) {
-      capabilities.widevine = await this.checkWidevineSupport();
-      if (capabilities.widevine) {
-        capabilities.supportedType = DRMTypeEnum.WIDEVINE;
-      }
-    }
-
-    // Check for PlayReady (Edge, IE)
-    if (!capabilities.supportedType && this.isEdge()) {
-      capabilities.playready = await this.checkPlayReadySupport();
-      if (capabilities.playready) {
-        capabilities.supportedType = DRMTypeEnum.PLAYREADY;
-      }
-    }
-
-    this.capabilities = capabilities;
-    return capabilities;
-  }
-
-  /**
-   * Get recommended DRM type for current browser
-   */
-  async getRecommendedDRMType(): Promise<DRMType | null> {
-    const caps = await this.detectCapabilities();
-    return caps.supportedType;
-  }
-
-  /**
-   * Check if specific DRM type is supported
-   */
-  async isDRMTypeSupported(drmType: DRMType): Promise<boolean> {
-    const caps = await this.detectCapabilities();
-    switch (drmType) {
-      case DRMTypeEnum.WIDEVINE:
-        return caps.widevine;
-      case DRMTypeEnum.FAIRPLAY:
-        return caps.fairplay;
-      case DRMTypeEnum.PLAYREADY:
-        return caps.playready;
-      default:
-        return false;
-    }
-  }
-
-  /**
-   * Check if browser is Safari
-   */
-  private isSafari(): boolean {
-    const ua = navigator.userAgent.toLowerCase();
-    return ua.includes('safari') && !ua.includes('chrome') && !ua.includes('chromium');
-  }
-
-  /**
-   * Check if browser is WebKit-based
-   */
-  private isWebKitBased(): boolean {
-    return 'WebKitMediaKeys' in window;
-  }
-
-  /**
-   * Check if browser is Edge
-   */
-  private isEdge(): boolean {
-    const ua = navigator.userAgent.toLowerCase();
-    return ua.includes('edg/');
-  }
-
-  /**
-   * Check FairPlay support
-   */
-  private async checkFairPlaySupport(): Promise<boolean> {
-    try {
-      // Check for WebKit-specific FairPlay API
-      if ('WebKitMediaKeys' in window) {
-        return true;
-      }
-
-      // Check via EME API
-      if (navigator.requestMediaKeySystemAccess) {
-        const config: MediaKeySystemConfiguration[] = [{
-          initDataTypes: ['sinf', 'skd'],
-          videoCapabilities: [{ contentType: 'application/vnd.apple.mpegurl' }],
-        }];
-
-        for (const keySystem of KEY_SYSTEMS[DRMTypeEnum.FAIRPLAY]) {
-          try {
-            await navigator.requestMediaKeySystemAccess(keySystem, config);
-            return true;
-          } catch (e) {
-            // Try next key system
-            continue;
-          }
-        }
-      }
-
-      return false;
-    } catch {
-      return false;
-    }
-  }
-
-  /**
-   * Check Widevine support
-   */
-  private async checkWidevineSupport(): Promise<boolean> {
-    try {
-      if (!navigator.requestMediaKeySystemAccess) {
-        console.warn('[BrowserDetector] EME API (requestMediaKeySystemAccess) not available. Secure context check:', window.isSecureContext);
-        return false;
-      }
-
-      const configs: MediaKeySystemConfiguration[] = [
-        // Standard config with robustness
-        {
-          initDataTypes: ['cenc'],
-          videoCapabilities: [{
-            contentType: 'video/mp4; codecs="avc1.42E01E"',
-            robustness: 'SW_SECURE_CRYPTO'
-          }],
-          audioCapabilities: [{
-            contentType: 'audio/mp4; codecs="mp4a.40.2"',
-            robustness: 'SW_SECURE_CRYPTO'
-          }]
-        },
-        // More permissive config (no robustness)
-        {
-          initDataTypes: ['cenc'],
-          videoCapabilities: [{
-            contentType: 'video/mp4; codecs="avc1.42E01E"'
-          }]
-        },
-        // Baseline config
-        {
-          initDataTypes: ['cenc'],
-          videoCapabilities: [{
-            contentType: 'video/mp4; codecs="avc1.4d401e"'
-          }]
-        }
-      ];
-
-      for (const keySystem of KEY_SYSTEMS[DRMTypeEnum.WIDEVINE]) {
-        for (const config of configs) {
-          try {
-            await navigator.requestMediaKeySystemAccess(keySystem, [config]);
-            console.log(`[BrowserDetector] Widevine supported with system: ${keySystem} and config:`, config);
-            return true;
-          } catch (e) {
-            // Try next config
-            continue;
-          }
-        }
-      }
-
-      console.warn('[BrowserDetector] Widevine support check failed for all configurations');
-      return false;
-    } catch (err) {
-      console.error('[BrowserDetector] Error checking Widevine support:', err);
-      return false;
-    }
-  }
-
-  /**
-   * Check PlayReady support
-   */
-  private async checkPlayReadySupport(): Promise<boolean> {
-    try {
-      if (!navigator.requestMediaKeySystemAccess) {
-        return false;
-      }
-
-      const configs: MediaKeySystemConfiguration[] = [
-        // Standard config
-        {
-          initDataTypes: ['cenc'],
-          videoCapabilities: [{
-            contentType: 'video/mp4; codecs="avc1.42E01E"',
-            robustness: 'SW_SECURE_CRYPTO'
-          }],
-          audioCapabilities: [{
-            contentType: 'audio/mp4; codecs="mp4a.40.2"',
-            robustness: 'SW_SECURE_CRYPTO'
-          }]
-        },
-        // More permissive config
-        {
-          initDataTypes: ['cenc'],
-          videoCapabilities: [{
-            contentType: 'video/mp4; codecs="avc1.42E01E"'
-          }]
-        }
-      ];
-
-      for (const keySystem of KEY_SYSTEMS[DRMTypeEnum.PLAYREADY]) {
-        for (const config of configs) {
-          try {
-            await navigator.requestMediaKeySystemAccess(keySystem, [config]);
-            console.log(`[BrowserDetector] PlayReady supported with system: ${keySystem} and config:`, config);
-            return true;
-          } catch (e) {
-            // Try next config
-            continue;
-          }
-        }
-      }
-
-      console.warn('[BrowserDetector] PlayReady support check failed for all configurations');
-      return false;
-    } catch (err) {
-      console.error('[BrowserDetector] Error checking PlayReady support:', err);
-      return false;
-    }
-  }
-
-  /**
-   * Get user-friendly browser name
-   */
-  getBrowserName(): string {
-    const ua = navigator.userAgent.toLowerCase();
-
-    if (ua.includes('edg/')) return 'Edge';
-    if (ua.includes('chrome') || ua.includes('chromium')) return 'Chrome';
-    if (ua.includes('firefox')) return 'Firefox';
-    if (ua.includes('safari')) return 'Safari';
-    if (ua.includes('opera') || ua.includes('opr/')) return 'Opera';
-
-    return 'Unknown';
-  }
-
-  /**
-   * Reset cached capabilities (useful for testing)
-   */
-  resetCapabilities(): void {
-    this.capabilities = null;
-  }
-}

package/packages/web/src/drm/utils/CertificateManager.ts

@@ -1,86 +0,0 @@
-/**
- * Certificate Manager
- * Manages FairPlay DRM certificates with in-memory caching
- */
-
-export class CertificateManager {
-  private static instance: CertificateManager;
-  private cache: Map<string, ArrayBuffer>;
-  private maxCacheSize: number = 10; // Max number of certificates to cache
-
-  private constructor() {
-    this.cache = new Map();
-  }
-
-  static getInstance(): CertificateManager {
-    if (!CertificateManager.instance) {
-      CertificateManager.instance = new CertificateManager();
-    }
-    return CertificateManager.instance;
-  }
-
-  /**
-   * Get certificate from cache
-   */
-  getCertificate(url: string): ArrayBuffer | null {
-    return this.cache.get(url) || null;
-  }
-
-  /**
-   * Store certificate in cache
-   */
-  setCertificate(url: string, certificate: ArrayBuffer): void {
-    // Implement LRU eviction if cache is full
-    if (this.cache.size >= this.maxCacheSize && !this.cache.has(url)) {
-      const firstKey = this.cache.keys().next().value;
-      if (firstKey) {
-        this.cache.delete(firstKey);
-      }
-    }
-
-    this.cache.set(url, certificate);
-  }
-
-  /**
-   * Check if certificate is cached
-   */
-  hasCertificate(url: string): boolean {
-    return this.cache.has(url);
-  }
-
-  /**
-   * Clear all cached certificates
-   */
-  clearCache(): void {
-    this.cache.clear();
-  }
-
-  /**
-   * Remove specific certificate from cache
-   */
-  removeCertificate(url: string): boolean {
-    return this.cache.delete(url);
-  }
-
-  /**
-   * Get cache size
-   */
-  getCacheSize(): number {
-    return this.cache.size;
-  }
-
-  /**
-   * Set max cache size
-   */
-  setMaxCacheSize(size: number): void {
-    this.maxCacheSize = size;
-
-    // Evict old entries if current size exceeds new max
-    while (this.cache.size > this.maxCacheSize) {
-      const firstKey = this.cache.keys().next().value;
-      if (firstKey) {
-        this.cache.delete(firstKey);
-      }
-    }
-  }
-}

package/packages/web/src/drm/utils/DRMErrorHandler.ts

@@ -1,84 +0,0 @@
-/**
- * DRM Error Handler
- * Converts DRM errors to user-friendly messages
- */
-
-import { DRMError, DRMErrorCode } from '../types/DRMTypes';
-
-export class DRMErrorHandler {
-  /**
-   * Get user-friendly error message
-   */
-  static getUserFriendlyMessage(error: DRMError): string {
-    switch (error.code) {
-      case DRMErrorCode.UNSUPPORTED_BROWSER:
-        return 'DRM is not supported in this browser. Please use Chrome, Safari, Firefox, or Edge.';
-
-      case DRMErrorCode.CERTIFICATE_LOAD_FAILED:
-        return 'Failed to load DRM certificate. Please check your internet connection.';
-
-      case DRMErrorCode.LICENSE_REQUEST_FAILED:
-        return 'Failed to obtain content license. Please check your internet connection and try again.';
-
-      case DRMErrorCode.KEY_SYSTEM_ACCESS_DENIED:
-        return 'Access to DRM system was denied. Please ensure DRM is enabled in your browser settings.';
-
-      case DRMErrorCode.MEDIA_KEYS_CREATION_FAILED:
-        return 'Failed to initialize DRM protection. Please try refreshing the page.';
-
-      case DRMErrorCode.SESSION_CREATION_FAILED:
-        return 'Failed to create secure playback session. Please try again.';
-
-      case DRMErrorCode.LICENSE_INVALID:
-        return 'Invalid or expired content license. You may not have permission to view this content.';
-
-      case DRMErrorCode.CONFIGURATION_ERROR:
-        return 'DRM configuration error. Please contact support.';
-
-      case DRMErrorCode.NETWORK_ERROR:
-        return 'Network error while loading protected content. Please check your internet connection.';
-
-      case DRMErrorCode.TIMEOUT:
-        return 'DRM initialization timed out. Please try again.';
-
-      default:
-        return 'An error occurred while loading protected content. Please try again.';
-    }
-  }
-
-  /**
-   * Get technical error message for developers
-   */
-  static getTechnicalMessage(error: DRMError): string {
-    let message = `[${error.code}] ${error.message}`;
-
-    if (error.details) {
-      message += `\nDetails: ${JSON.stringify(error.details, null, 2)}`;
-    }
-
-    if (error.systemError) {
-      message += `\nSystem Error: ${error.systemError}`;
-    }
-
-    return message;
-  }
-
-  /**
-   * Create standardized DRM error
-   */
-  static createError(
-    code: DRMErrorCode,
-    message: string,
-    fatal: boolean = true,
-    details?: any,
-    systemError?: any
-  ): DRMError {
-    return {
-      code,
-      message,
-      fatal,
-      details,
-      systemError,
-    };
-  }
-}