unified-video-framework 1.4.425 → 1.4.426

package/packages/web/src/drm/DRMManager.ts

@@ -1,224 +0,0 @@
-/**
- * DRM Manager
- * Main orchestrator for all DRM systems
- * Provides a unified interface for HLS.js, dash.js, and native playback
- */
-
-import type { DRMType, DRMConfig } from '@unified-video/core';
-import { DRMType as DRMTypeEnum } from '@unified-video/core';
-import { ExtendedDRMConfig, DRMInitResult, DRMError, DRMErrorCode, DRMCapabilities } from './types/DRMTypes';
-import { BrowserDetector } from './utils/BrowserDetector';
-import { BunnyNetProvider } from './providers/BunnyNetProvider';
-import { WidevineDRM } from './systems/WidevineDRM';
-import { FairPlayDRM } from './systems/FairPlayDRM';
-import { PlayReadyDRM } from './systems/PlayReadyDRM';
-import { BaseDRM } from './systems/BaseDRM';
-import { DRMErrorHandler } from './utils/DRMErrorHandler';
-
-export class DRMManager {
-  private videoElement: HTMLVideoElement;
-  private config: ExtendedDRMConfig;
-  private drmSystem: BaseDRM | null = null;
-  private browserDetector: BrowserDetector;
-  private debug: boolean = false;
-
-  constructor(videoElement: HTMLVideoElement, config: DRMConfig, debug: boolean = false) {
-    this.videoElement = videoElement;
-    this.config = this.normalizeConfig(config);
-    this.debug = debug || this.config.debug || false;
-    this.browserDetector = BrowserDetector.getInstance();
-  }
-
-  /**
-   * Initialize DRM system based on browser capabilities
-   */
-  async initialize(): Promise<DRMInitResult> {
-    try {
-      this.log('Initializing DRM system...');
-
-      // Check for secure context - EME requires HTTPS or localhost
-      if (typeof window !== 'undefined' && !window.isSecureContext) {
-        throw DRMErrorHandler.createError(
-          DRMErrorCode.SECURE_CONTEXT_REQUIRED,
-          'DRM requires a secure context (HTTPS or localhost). Please ensure your site is running over HTTPS.',
-          true
-        );
-      }
-
-      // Detect browser capabilities
-      const capabilities = await this.browserDetector.detectCapabilities();
-      this.log('Browser DRM capabilities:', capabilities);
-
-      // Determine which DRM system to use
-      const drmType = this.selectDRMType(capabilities);
-      if (!drmType) {
-        const browserName = this.browserDetector.getBrowserName();
-        throw DRMErrorHandler.createError(
-          DRMErrorCode.UNSUPPORTED_BROWSER,
-          `No supported DRM system found in ${browserName}. Please use Chrome, Safari, Firefox, or Edge.`,
-          true,
-          { browser: browserName, capabilities }
-        );
-      }
-
-      this.log(`Selected DRM type: ${drmType}`);
-
-      // Create appropriate DRM system
-      this.drmSystem = this.createDRMSystem(drmType);
-
-      // Initialize the DRM system
-      await this.drmSystem.initialize();
-
-      return {
-        success: true,
-        drmType,
-        keySystem: this.drmSystem.getKeySystem(),
-      };
-    } catch (error: any) {
-      this.log('DRM initialization failed:', error);
-
-      const capabilities = await this.browserDetector.detectCapabilities();
-      const drmError = error.code && error.code.startsWith('DRM_')
-        ? error
-        : DRMErrorHandler.createError(
-          DRMErrorCode.CONFIGURATION_ERROR,
-          error.message || 'DRM initialization failed',
-          true,
-          { ...error, capabilities }
-        );
-
-      return {
-        success: false,
-        drmType: this.config.type,
-        keySystem: '',
-        error: drmError,
-      };
-    }
-  }
-
-  /**
-   * Get HLS.js configuration for DRM
-   */
-  getHLSConfig(): any {
-    if (!this.drmSystem) {
-      throw new Error('DRM system not initialized. Call initialize() first.');
-    }
-
-    return this.drmSystem.getHLSConfig();
-  }
-
-  /**
-   * Get dash.js protection data for DRM
-   */
-  getDashProtectionData(): any {
-    if (!this.drmSystem) {
-      throw new Error('DRM system not initialized. Call initialize() first.');
-    }
-
-    return this.drmSystem.getDashProtectionData();
-  }
-
-  /**
-   * Cleanup DRM resources
-   */
-  async destroy(): Promise<void> {
-    if (this.drmSystem) {
-      this.log('Destroying DRM system');
-      await this.drmSystem.destroy();
-      this.drmSystem = null;
-    }
-  }
-
-  /**
-   * Select appropriate DRM type based on config and capabilities
-   */
-  private selectDRMType(capabilities: DRMCapabilities): DRMType | null {
-    // If config specifies a type and it's supported, use it
-    if (this.config.type) {
-      const typeSupported = this.isDRMTypeSupported(this.config.type, capabilities);
-      if (typeSupported) {
-        return this.config.type;
-      }
-
-      this.log(`Requested DRM type ${this.config.type} not supported, falling back to browser default`);
-    }
-
-    // Otherwise, use browser's preferred DRM system
-    return capabilities.supportedType;
-  }
-
-  /**
-   * Check if specific DRM type is supported
-   */
-  private isDRMTypeSupported(drmType: DRMType, capabilities: DRMCapabilities): boolean {
-    switch (drmType) {
-      case DRMTypeEnum.WIDEVINE:
-        return capabilities.widevine;
-      case DRMTypeEnum.FAIRPLAY:
-        return capabilities.fairplay;
-      case DRMTypeEnum.PLAYREADY:
-        return capabilities.playready;
-      default:
-        return false;
-    }
-  }
-
-  /**
-   * Create DRM system instance
-   */
-  private createDRMSystem(drmType: DRMType): BaseDRM {
-    switch (drmType) {
-      case DRMTypeEnum.FAIRPLAY:
-        return new FairPlayDRM(this.videoElement, this.config, this.debug);
-
-      case DRMTypeEnum.WIDEVINE:
-        return new WidevineDRM(this.videoElement, this.config, this.debug);
-
-      case DRMTypeEnum.PLAYREADY:
-        return new PlayReadyDRM(this.videoElement, this.config, this.debug);
-
-      default:
-        throw DRMErrorHandler.createError(
-          DRMErrorCode.CONFIGURATION_ERROR,
-          `Unsupported DRM type: ${drmType}`,
-          true
-        );
-    }
-  }
-
-  /**
-   * Normalize and enrich DRM config
-   */
-  private normalizeConfig(config: DRMConfig): ExtendedDRMConfig {
-    const extended = { ...config } as ExtendedDRMConfig;
-
-    // Auto-detect Bunny.net and enhance config
-    if (BunnyNetProvider.isBunnyNetConfig(config)) {
-      extended.provider = 'bunny';
-
-      // Extract IDs if available
-      const ids = BunnyNetProvider.extractIdsFromUrl(config.licenseUrl);
-      if (ids.libraryId) extended.libraryId = ids.libraryId;
-      if (ids.videoId) extended.videoId = ids.videoId;
-
-      this.log('Detected Bunny.net DRM configuration');
-    }
-
-    // Set defaults
-    extended.retryConfig = extended.retryConfig || {
-      maxRetries: 3,
-      retryDelay: 1000,
-    };
-
-    return extended;
-  }
-
-  /**
-   * Debug logging
-   */
-  private log(...args: any[]): void {
-    if (this.debug) {
-      console.log('[DRMManager]', ...args);
-    }
-  }
-}

package/packages/web/src/drm/index.ts

@@ -1,37 +0,0 @@
-/**
- * DRM System - Public API
- * Exports for the DRM system
- */
-
-// Main DRM Manager
-export { DRMManager } from './DRMManager';
-
-// Providers
-export { BunnyNetProvider } from './providers/BunnyNetProvider';
-export { GenericProvider } from './providers/GenericProvider';
-
-// Types
-export type {
-  ExtendedDRMConfig,
-  DRMCapabilities,
-  LicenseRequest,
-  LicenseResponse,
-  DRMInitResult,
-  DRMError,
-} from './types/DRMTypes';
-
-export { DRMErrorCode, KEY_SYSTEMS } from './types/DRMTypes';
-
-export type { BunnyNetConfig, BunnyNetEndpoints } from './types/BunnyNetTypes';
-export { BUNNY_NET_BASE_URL, BUNNY_NET_ENDPOINTS } from './types/BunnyNetTypes';
-
-// Utilities
-export { BrowserDetector } from './utils/BrowserDetector';
-export { DRMErrorHandler } from './utils/DRMErrorHandler';
-export { CertificateManager } from './utils/CertificateManager';
-
-// DRM Systems (for advanced usage)
-export { BaseDRM } from './systems/BaseDRM';
-export { WidevineDRM } from './systems/WidevineDRM';
-export { FairPlayDRM } from './systems/FairPlayDRM';
-export { PlayReadyDRM } from './systems/PlayReadyDRM';

package/packages/web/src/drm/providers/BunnyNetProvider.ts

@@ -1,171 +0,0 @@
-/**
- * Bunny.net DRM Provider
- * Helper utilities for Bunny.net MediaCage DRM integration
- */
-
-import type { DRMType, DRMConfig } from '@unified-video/core';
-import { DRMType as DRMTypeEnum } from '@unified-video/core';
-import { ExtendedDRMConfig } from '../types/DRMTypes';
-import { BunnyNetConfig, BUNNY_NET_ENDPOINTS } from '../types/BunnyNetTypes';
-
-export class BunnyNetProvider {
-  /**
-   * Generate complete DRM config from Bunny.net credentials
-   */
-  static createDRMConfig(config: BunnyNetConfig): ExtendedDRMConfig {
-    const { libraryId, videoId, drmType = DRMTypeEnum.WIDEVINE } = config;
-
-    const drmConfig: ExtendedDRMConfig = {
-      type: drmType,
-      licenseUrl: this.getLicenseUrl(drmType, libraryId, videoId),
-      provider: 'bunny',
-      libraryId,
-      videoId,
-    };
-
-    // Add FairPlay-specific settings
-    if (drmType === DRMTypeEnum.FAIRPLAY) {
-      drmConfig.certificateUrl = this.getCertificateUrl(libraryId);
-      drmConfig.fairplayOptions = {
-        certificateUrl: this.getCertificateUrl(libraryId),
-        licenseUrl: this.getLicenseUrl(drmType, libraryId, videoId),
-      };
-    }
-
-    // Add Widevine-specific settings
-    if (drmType === DRMTypeEnum.WIDEVINE) {
-      drmConfig.widevineOptions = {
-        licenseUrl: this.getLicenseUrl(drmType, libraryId, videoId),
-      };
-    }
-
-    // Add PlayReady-specific settings
-    if (drmType === DRMTypeEnum.PLAYREADY) {
-      drmConfig.playreadyOptions = {
-        licenseUrl: this.getLicenseUrl(drmType, libraryId, videoId),
-      };
-    }
-
-    return drmConfig;
-  }
-
-  /**
-   * Get license URL for specific DRM type
-   */
-  static getLicenseUrl(drmType: DRMType, libraryId: string, videoId: string): string {
-    switch (drmType) {
-      case DRMTypeEnum.WIDEVINE:
-        return BUNNY_NET_ENDPOINTS.WIDEVINE_LICENSE(libraryId, videoId);
-
-      case DRMTypeEnum.FAIRPLAY:
-        return BUNNY_NET_ENDPOINTS.FAIRPLAY_LICENSE(libraryId, videoId);
-
-      case DRMTypeEnum.PLAYREADY:
-        return BUNNY_NET_ENDPOINTS.PLAYREADY_LICENSE(libraryId, videoId);
-
-      default:
-        throw new Error(`Unsupported DRM type for Bunny.net: ${drmType}`);
-    }
-  }
-
-  /**
-   * Get certificate URL (FairPlay only)
-   */
-  static getCertificateUrl(libraryId: string): string {
-    return BUNNY_NET_ENDPOINTS.FAIRPLAY_CERTIFICATE(libraryId);
-  }
-
-  /**
-   * Validate Bunny.net DRM configuration
-   */
-  static validateConfig(config: BunnyNetConfig): { valid: boolean; error?: string } {
-    if (!config.libraryId || !config.videoId) {
-      return {
-        valid: false,
-        error: 'Bunny.net DRM requires libraryId and videoId',
-      };
-    }
-
-    if (!/^\d+$/.test(config.libraryId)) {
-      return {
-        valid: false,
-        error: 'libraryId must be a numeric string',
-      };
-    }
-
-    return { valid: true };
-  }
-
-  /**
-   * Auto-detect if a DRM config is for Bunny.net
-   */
-  static isBunnyNetConfig(config: DRMConfig): boolean {
-    return !!(
-      config.licenseUrl?.includes('bunnycdn.com') ||
-      config.certificateUrl?.includes('bunnycdn.com') ||
-      config.fairplayOptions?.licenseUrl?.includes('bunnycdn.com') ||
-      config.fairplayOptions?.certificateUrl?.includes('bunnycdn.com') ||
-      config.widevineOptions?.licenseUrl?.includes('bunnycdn.com') ||
-      config.playreadyOptions?.licenseUrl?.includes('bunnycdn.com')
-    );
-  }
-
-  /**
-   * Extract library and video IDs from Bunny.net URLs
-   */
-  static extractIdsFromUrl(url: string): { libraryId?: string; videoId?: string } {
-    if (!url) return {};
-
-    const widevineMatch = url.match(/WidevineLicense\/([^/]+)\/([^/?]+)/);
-    const fairplayLicenseMatch = url.match(/FairPlay\/([^/]+)\/license.*videoId=([^&]+)/);
-    const fairplayCertMatch = url.match(/FairPlay\/([^/]+)\/certificate/);
-    const playreadyMatch = url.match(/PlayReadyLicense\/([^/]+)\/([^/?]+)/);
-
-    if (widevineMatch) {
-      return { libraryId: widevineMatch[1], videoId: widevineMatch[2] };
-    }
-    if (fairplayLicenseMatch) {
-      return { libraryId: fairplayLicenseMatch[1], videoId: fairplayLicenseMatch[2] };
-    }
-    if (fairplayCertMatch) {
-      return { libraryId: fairplayCertMatch[1] };
-    }
-    if (playreadyMatch) {
-      return { libraryId: playreadyMatch[1], videoId: playreadyMatch[2] };
-    }
-
-    return {};
-  }
-
-  /**
-   * Create multi-DRM config for Bunny.net (auto-detects browser)
-   */
-  static createMultiDRMConfig(libraryId: string, videoId: string): ExtendedDRMConfig {
-    // Primary Widevine config with FairPlay fallback
-    const config: ExtendedDRMConfig = {
-      type: DRMTypeEnum.WIDEVINE,
-      licenseUrl: this.getLicenseUrl(DRMTypeEnum.WIDEVINE, libraryId, videoId),
-      provider: 'bunny',
-      libraryId,
-      videoId,
-
-      // Widevine options
-      widevineOptions: {
-        licenseUrl: this.getLicenseUrl(DRMTypeEnum.WIDEVINE, libraryId, videoId),
-      },
-
-      // FairPlay options (for Safari fallback)
-      fairplayOptions: {
-        certificateUrl: this.getCertificateUrl(libraryId),
-        licenseUrl: this.getLicenseUrl(DRMTypeEnum.FAIRPLAY, libraryId, videoId),
-      },
-
-      // PlayReady options (for Edge fallback)
-      playreadyOptions: {
-        licenseUrl: this.getLicenseUrl(DRMTypeEnum.PLAYREADY, libraryId, videoId),
-      },
-    };
-
-    return config;
-  }
-}

package/packages/web/src/drm/providers/GenericProvider.ts

@@ -1,151 +0,0 @@
-/**
- * Generic DRM Provider
- * Helper utilities for generic DRM configurations
- */
-
-import type { DRMType, DRMConfig } from '@unified-video/core';
-import { ExtendedDRMConfig } from '../types/DRMTypes';
-
-export class GenericProvider {
-  /**
-   * Create generic DRM config with sensible defaults
-   */
-  static createDRMConfig(config: {
-    drmType: DRMType;
-    licenseUrl: string;
-    certificateUrl?: string;
-    headers?: Record<string, string>;
-    customData?: string;
-  }): ExtendedDRMConfig {
-    const drmConfig: ExtendedDRMConfig = {
-      type: config.drmType,
-      licenseUrl: config.licenseUrl,
-      certificateUrl: config.certificateUrl,
-      headers: config.headers,
-      customData: config.customData,
-      provider: 'generic',
-    };
-
-    // Add type-specific options
-    const DRMTypeEnum = require('../../../core/src/interfaces').DRMType;
-    switch (config.drmType) {
-      case DRMTypeEnum.FAIRPLAY:
-        if (config.certificateUrl) {
-          drmConfig.fairplayOptions = {
-            certificateUrl: config.certificateUrl,
-            licenseUrl: config.licenseUrl,
-          };
-        }
-        break;
-
-      case DRMTypeEnum.WIDEVINE:
-        drmConfig.widevineOptions = {
-          licenseUrl: config.licenseUrl,
-        };
-        break;
-
-      case DRMTypeEnum.PLAYREADY:
-        drmConfig.playreadyOptions = {
-          licenseUrl: config.licenseUrl,
-          customData: config.customData,
-        };
-        break;
-    }
-
-    return drmConfig;
-  }
-
-  /**
-   * Validate generic DRM configuration
-   */
-  static validateConfig(config: DRMConfig): { valid: boolean; error?: string } {
-    if (!config.type) {
-      return {
-        valid: false,
-        error: 'DRM type is required',
-      };
-    }
-
-    if (!config.licenseUrl) {
-      return {
-        valid: false,
-        error: 'License URL is required',
-      };
-    }
-
-    // FairPlay requires certificate URL
-    const DRMTypeEnum = require('../../../core/src/interfaces').DRMType;
-    if (config.type === DRMTypeEnum.FAIRPLAY) {
-      const certificateUrl = config.certificateUrl || config.fairplayOptions?.certificateUrl;
-      if (!certificateUrl) {
-        return {
-          valid: false,
-          error: 'FairPlay requires certificateUrl',
-        };
-      }
-    }
-
-    // Validate URL format
-    try {
-      new URL(config.licenseUrl);
-    } catch (e) {
-      return {
-        valid: false,
-        error: 'Invalid license URL format',
-      };
-    }
-
-    if (config.certificateUrl) {
-      try {
-        new URL(config.certificateUrl);
-      } catch (e) {
-        return {
-          valid: false,
-          error: 'Invalid certificate URL format',
-        };
-      }
-    }
-
-    return { valid: true };
-  }
-
-  /**
-   * Create multi-DRM config for generic provider
-   */
-  static createMultiDRMConfig(config: {
-    widevine: { licenseUrl: string };
-    fairplay: { licenseUrl: string; certificateUrl: string };
-    playready?: { licenseUrl: string; customData?: string };
-    headers?: Record<string, string>;
-  }): ExtendedDRMConfig {
-    // Primary Widevine config with FairPlay and PlayReady fallbacks
-    const DRMTypeEnum = require('../../../core/src/interfaces').DRMType;
-    const drmConfig: ExtendedDRMConfig = {
-      type: DRMTypeEnum.WIDEVINE,
-      licenseUrl: config.widevine.licenseUrl,
-      provider: 'generic',
-      headers: config.headers,
-
-      // Widevine options
-      widevineOptions: {
-        licenseUrl: config.widevine.licenseUrl,
-      },
-
-      // FairPlay options
-      fairplayOptions: {
-        certificateUrl: config.fairplay.certificateUrl,
-        licenseUrl: config.fairplay.licenseUrl,
-      },
-
-      // PlayReady options (optional)
-      playreadyOptions: config.playready
-        ? {
-            licenseUrl: config.playready.licenseUrl,
-            customData: config.playready.customData,
-          }
-        : undefined,
-    };
-
-    return drmConfig;
-  }
-}

package/packages/web/src/drm/systems/BaseDRM.ts

@@ -1,68 +0,0 @@
-/**
- * Base DRM System
- * Abstract base class for all DRM system implementations
- */
-
-import { ExtendedDRMConfig, LicenseRequest, LicenseResponse } from '../types/DRMTypes';
-import { LicenseRequestHandler } from '../utils/LicenseRequestHandler';
-
-export abstract class BaseDRM {
-  protected videoElement: HTMLVideoElement;
-  protected config: ExtendedDRMConfig;
-  protected debug: boolean;
-  protected licenseHandler: LicenseRequestHandler;
-  protected mediaKeys: MediaKeys | null = null;
-  protected keySession: MediaKeySession | null = null;
-
-  constructor(videoElement: HTMLVideoElement, config: ExtendedDRMConfig, debug: boolean = false) {
-    this.videoElement = videoElement;
-    this.config = config;
-    this.debug = debug;
-    this.licenseHandler = new LicenseRequestHandler(config, debug);
-  }
-
-  /**
-   * Initialize DRM system
-   */
-  abstract initialize(): Promise<void>;
-
-  /**
-   * Get key system identifier
-   */
-  abstract getKeySystem(): string;
-
-  /**
-   * Get HLS.js configuration
-   */
-  abstract getHLSConfig(): any;
-
-  /**
-   * Get dash.js protection data
-   */
-  abstract getDashProtectionData(): any;
-
-  /**
-   * Cleanup resources
-   */
-  async destroy(): Promise<void> {
-    if (this.keySession) {
-      try {
-        await this.keySession.close();
-      } catch (error) {
-        this.log('Error closing key session:', error);
-      }
-      this.keySession = null;
-    }
-
-    this.mediaKeys = null;
-  }
-
-  /**
-   * Debug logging
-   */
-  protected log(...args: any[]): void {
-    if (this.debug) {
-      console.log(`[${this.constructor.name}]`, ...args);
-    }
-  }
-}