unified-video-framework 1.4.413 → 1.4.414

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

@@ -1,170 +1,171 @@
-/**
- * Bunny.net DRM Provider
- * Helper utilities for Bunny.net MediaCage DRM integration
- */
-
-import { DRMType, DRMConfig } 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 = DRMType.WIDEVINE } = config;
-
-    const drmConfig: ExtendedDRMConfig = {
-      type: drmType,
-      licenseUrl: this.getLicenseUrl(drmType, libraryId, videoId),
-      provider: 'bunny',
-      libraryId,
-      videoId,
-    };
-
-    // Add FairPlay-specific settings
-    if (drmType === DRMType.FAIRPLAY) {
-      drmConfig.certificateUrl = this.getCertificateUrl(libraryId);
-      drmConfig.fairplayOptions = {
-        certificateUrl: this.getCertificateUrl(libraryId),
-        licenseUrl: this.getLicenseUrl(drmType, libraryId, videoId),
-      };
-    }
-
-    // Add Widevine-specific settings
-    if (drmType === DRMType.WIDEVINE) {
-      drmConfig.widevineOptions = {
-        licenseUrl: this.getLicenseUrl(drmType, libraryId, videoId),
-      };
-    }
-
-    // Add PlayReady-specific settings
-    if (drmType === DRMType.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 DRMType.WIDEVINE:
-        return BUNNY_NET_ENDPOINTS.WIDEVINE_LICENSE(libraryId, videoId);
-
-      case DRMType.FAIRPLAY:
-        return BUNNY_NET_ENDPOINTS.FAIRPLAY_LICENSE(libraryId, videoId);
-
-      case DRMType.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: DRMType.WIDEVINE,
-      licenseUrl: this.getLicenseUrl(DRMType.WIDEVINE, libraryId, videoId),
-      provider: 'bunny',
-      libraryId,
-      videoId,
-
-      // Widevine options
-      widevineOptions: {
-        licenseUrl: this.getLicenseUrl(DRMType.WIDEVINE, libraryId, videoId),
-      },
-
-      // FairPlay options (for Safari fallback)
-      fairplayOptions: {
-        certificateUrl: this.getCertificateUrl(libraryId),
-        licenseUrl: this.getLicenseUrl(DRMType.FAIRPLAY, libraryId, videoId),
-      },
-
-      // PlayReady options (for Edge fallback)
-      playreadyOptions: {
-        licenseUrl: this.getLicenseUrl(DRMType.PLAYREADY, libraryId, videoId),
-      },
-    };
-
-    return config;
-  }
-}
+/**
+ * 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,148 +1,151 @@
-/**
- * Generic DRM Provider
- * Helper utilities for generic DRM configurations
- */
-
-import { 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
-    switch (config.drmType) {
-      case DRMType.FAIRPLAY:
-        if (config.certificateUrl) {
-          drmConfig.fairplayOptions = {
-            certificateUrl: config.certificateUrl,
-            licenseUrl: config.licenseUrl,
-          };
-        }
-        break;
-
-      case DRMType.WIDEVINE:
-        drmConfig.widevineOptions = {
-          licenseUrl: config.licenseUrl,
-        };
-        break;
-
-      case DRMType.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
-    if (config.type === DRMType.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 drmConfig: ExtendedDRMConfig = {
-      type: DRMType.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;
-  }
-}
+/**
+ * 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;
+  }
+}