unified-video-framework 1.4.413 → 1.4.414

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

@@ -1,91 +1,92 @@
-/**
- * DRM Type Definitions
- * Core type definitions and enums for DRM functionality
- */
-
-import { DRMConfig, DRMType } 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',
-  TIMEOUT = 'DRM_TIMEOUT',
-}
-
-// Key system mappings
-export const KEY_SYSTEMS: Record<DRMType, string[]> = {
-  [DRMType.WIDEVINE]: ['com.widevine.alpha'],
-  [DRMType.PLAYREADY]: ['com.microsoft.playready', 'com.microsoft.playready.recommendation'],
-  [DRMType.FAIRPLAY]: ['com.apple.fps.1_0', 'com.apple.fps'],
-  [DRMType.CLEARKEY]: ['webkit-org.w3.clearkey', 'org.w3.clearkey'],
-};
+/**
+ * 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',
+  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,232 +1,233 @@
-/**
- * Browser DRM Detector
- * Detects browser capabilities and determines optimal DRM system
- */
-
-import { DRMType } from '@unified-video/core';
-import { DRMCapabilities, KEY_SYSTEMS } from '../types/DRMTypes';
-
-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 = DRMType.FAIRPLAY;
-      }
-    }
-
-    // Check for Widevine (Chrome, Firefox, Edge)
-    if (!capabilities.supportedType) {
-      capabilities.widevine = await this.checkWidevineSupport();
-      if (capabilities.widevine) {
-        capabilities.supportedType = DRMType.WIDEVINE;
-      }
-    }
-
-    // Check for PlayReady (Edge, IE)
-    if (!capabilities.supportedType && this.isEdge()) {
-      capabilities.playready = await this.checkPlayReadySupport();
-      if (capabilities.playready) {
-        capabilities.supportedType = DRMType.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 DRMType.WIDEVINE:
-        return caps.widevine;
-      case DRMType.FAIRPLAY:
-        return caps.fairplay;
-      case DRMType.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[DRMType.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) {
-        return false;
-      }
-
-      const config: MediaKeySystemConfiguration[] = [{
-        initDataTypes: ['cenc'],
-        videoCapabilities: [{
-          contentType: 'video/mp4; codecs="avc1.42E01E"',
-        }],
-      }];
-
-      for (const keySystem of KEY_SYSTEMS[DRMType.WIDEVINE]) {
-        try {
-          await navigator.requestMediaKeySystemAccess(keySystem, config);
-          return true;
-        } catch (e) {
-          // Try next key system
-          continue;
-        }
-      }
-
-      return false;
-    } catch {
-      return false;
-    }
-  }
-
-  /**
-   * Check PlayReady support
-   */
-  private async checkPlayReadySupport(): Promise<boolean> {
-    try {
-      if (!navigator.requestMediaKeySystemAccess) {
-        return false;
-      }
-
-      const config: MediaKeySystemConfiguration[] = [{
-        initDataTypes: ['cenc'],
-        videoCapabilities: [{
-          contentType: 'video/mp4; codecs="avc1.42E01E"',
-        }],
-      }];
-
-      for (const keySystem of KEY_SYSTEMS[DRMType.PLAYREADY]) {
-        try {
-          await navigator.requestMediaKeySystemAccess(keySystem, config);
-          return true;
-        } catch (e) {
-          // Try next key system
-          continue;
-        }
-      }
-
-      return false;
-    } catch {
-      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;
-  }
-}
+/**
+ * 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) {
+        return false;
+      }
+
+      const config: MediaKeySystemConfiguration[] = [{
+        initDataTypes: ['cenc'],
+        videoCapabilities: [{
+          contentType: 'video/mp4; codecs="avc1.42E01E"',
+        }],
+      }];
+
+      for (const keySystem of KEY_SYSTEMS[DRMTypeEnum.WIDEVINE]) {
+        try {
+          await navigator.requestMediaKeySystemAccess(keySystem, config);
+          return true;
+        } catch (e) {
+          // Try next key system
+          continue;
+        }
+      }
+
+      return false;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * Check PlayReady support
+   */
+  private async checkPlayReadySupport(): Promise<boolean> {
+    try {
+      if (!navigator.requestMediaKeySystemAccess) {
+        return false;
+      }
+
+      const config: MediaKeySystemConfiguration[] = [{
+        initDataTypes: ['cenc'],
+        videoCapabilities: [{
+          contentType: 'video/mp4; codecs="avc1.42E01E"',
+        }],
+      }];
+
+      for (const keySystem of KEY_SYSTEMS[DRMTypeEnum.PLAYREADY]) {
+        try {
+          await navigator.requestMediaKeySystemAccess(keySystem, config);
+          return true;
+        } catch (e) {
+          // Try next key system
+          continue;
+        }
+      }
+
+      return false;
+    } catch {
+      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;
+  }
+}