@livepeer-frameworks/player-core 0.1.0 → 0.1.1

package/src/core/CodecUtils.ts

@@ -40,61 +40,61 @@ export function translateCodec(track: TrackInfo): string {
   }
 
   // Audio codecs
-  if (track.type === 'audio') {
+  if (track.type === "audio") {
     switch (codec) {
-      case 'AAC':
-      case 'MP4A':
-        return 'mp4a.40.2'; // AAC-LC
-      case 'MP3':
-        return 'mp4a.40.34'; // MP3 in MP4 container
-      case 'AC3':
-      case 'AC-3':
-        return 'ac-3';
-      case 'EAC3':
-      case 'EC3':
-      case 'E-AC3':
-      case 'EC-3':
-        return 'ec-3';
-      case 'OPUS':
-        return 'opus';
-      case 'VORBIS':
-        return 'vorbis';
-      case 'FLAC':
-        return 'flac';
-      case 'PCM':
-      case 'PCMS16LE':
-        return 'pcm';
+      case "AAC":
+      case "MP4A":
+        return "mp4a.40.2"; // AAC-LC
+      case "MP3":
+        return "mp4a.40.34"; // MP3 in MP4 container
+      case "AC3":
+      case "AC-3":
+        return "ac-3";
+      case "EAC3":
+      case "EC3":
+      case "E-AC3":
+      case "EC-3":
+        return "ec-3";
+      case "OPUS":
+        return "opus";
+      case "VORBIS":
+        return "vorbis";
+      case "FLAC":
+        return "flac";
+      case "PCM":
+      case "PCMS16LE":
+        return "pcm";
       default:
         return codec.toLowerCase();
     }
   }
 
   // Video codecs
-  if (track.type === 'video') {
+  if (track.type === "video") {
     switch (codec) {
-      case 'H264':
-      case 'AVC':
-      case 'AVC1': {
+      case "H264":
+      case "AVC":
+      case "AVC1": {
         // Try to extract profile/level from init data
         const profileLevel = extractH264Profile(track.init);
-        return profileLevel || 'avc1.42E01E'; // Default: Baseline Profile, Level 3.0
+        return profileLevel || "avc1.42E01E"; // Default: Baseline Profile, Level 3.0
       }
-      case 'H265':
-      case 'HEVC':
-      case 'HEV1':
-      case 'HVC1': {
+      case "H265":
+      case "HEVC":
+      case "HEV1":
+      case "HVC1": {
         // Try to extract profile/level from init data
         const profileLevel = extractHEVCProfile(track.init);
-        return profileLevel || 'hev1.1.6.L93.B0'; // Default: Main Profile, Level 3.1
+        return profileLevel || "hev1.1.6.L93.B0"; // Default: Main Profile, Level 3.1
       }
-      case 'VP8':
-        return 'vp8';
-      case 'VP9':
-        return 'vp09.00.10.08'; // Profile 0, Level 1.0, 8-bit
-      case 'AV1':
-        return 'av01.0.01M.08'; // Main Profile, Level 2.1, 8-bit
-      case 'THEORA':
-        return 'theora';
+      case "VP8":
+        return "vp8";
+      case "VP9":
+        return "vp09.00.10.08"; // Profile 0, Level 1.0, 8-bit
+      case "AV1":
+        return "av01.0.01M.08"; // Main Profile, Level 2.1, 8-bit
+      case "THEORA":
+        return "theora";
       default:
         return codec.toLowerCase();
     }
@@ -199,7 +199,7 @@ function extractHEVCProfile(init?: string): string | null {
  * Convert byte to 2-digit hex string
  */
 function toHex(byte: number): string {
-  return byte.toString(16).padStart(2, '0').toUpperCase();
+  return byte.toString(16).padStart(2, "0").toUpperCase();
 }
 
 /**
@@ -221,8 +221,8 @@ function base64ToBytes(base64: string): Uint8Array {
  * @param containerType - Container type (default: 'video/mp4')
  * @returns true if supported
  */
-export function isCodecSupported(codecString: string, containerType = 'video/mp4'): boolean {
-  if (typeof MediaSource === 'undefined' || !MediaSource.isTypeSupported) {
+export function isCodecSupported(codecString: string, containerType = "video/mp4"): boolean {
+  if (typeof MediaSource === "undefined" || !MediaSource.isTypeSupported) {
     return false;
   }
 
@@ -237,8 +237,11 @@ export function isCodecSupported(codecString: string, containerType = 'video/mp4
  * @param type - Track type to filter ('video' or 'audio')
  * @returns Best supported track or null
  */
-export function getBestSupportedTrack(tracks: TrackInfo[], type: 'video' | 'audio'): TrackInfo | null {
-  const filteredTracks = tracks.filter(t => t.type === type);
+export function getBestSupportedTrack(
+  tracks: TrackInfo[],
+  type: "video" | "audio"
+): TrackInfo | null {
+  const filteredTracks = tracks.filter((t) => t.type === type);
 
   for (const track of filteredTracks) {
     const codecString = translateCodec(track);

package/src/core/Disposable.ts

@@ -57,7 +57,7 @@ export abstract class BaseDisposable implements Disposable {
    * Throw if this object has been disposed.
    * Use at the start of methods that shouldn't run after disposal.
    */
-  protected throwIfDisposed(operation: string = 'operation'): void {
+  protected throwIfDisposed(operation: string = "operation"): void {
     if (this._disposed) {
       throw new Error(`Cannot perform ${operation} on disposed object`);
     }
@@ -80,7 +80,7 @@ export function disposeAll(...disposables: (Disposable | null | undefined)[]): v
       try {
         d.dispose();
       } catch (err) {
-        console.warn('[Disposable] Error during disposal:', err);
+        console.warn("[Disposable] Error during disposal:", err);
       }
     }
   }
@@ -104,13 +104,13 @@ export function createCompositeDisposable(
 
       for (const d of disposables) {
         try {
-          if (typeof d === 'function') {
+          if (typeof d === "function") {
             d();
           } else if (d && !d.disposed) {
             d.dispose();
           }
         } catch (err) {
-          console.warn('[CompositeDisposable] Error during disposal:', err);
+          console.warn("[CompositeDisposable] Error during disposal:", err);
         }
       }
     },

package/src/core/EventEmitter.ts

@@ -77,7 +77,7 @@ export class TypedEventEmitter<Events extends Record<string, any>> {
    * @param data - The event payload
    */
   protected emit<K extends keyof Events>(event: K, data: Events[K]): void {
-    this.listeners.get(event)?.forEach(listener => {
+    this.listeners.get(event)?.forEach((listener) => {
       try {
         listener(data);
       } catch (e) {

package/src/core/GatewayClient.ts

@@ -5,14 +5,14 @@
  * Extracted from useViewerEndpoints.ts for use in headless core.
  */
 
-import { TypedEventEmitter } from './EventEmitter';
-import type { ContentEndpoints, ContentType } from '../types';
+import { TypedEventEmitter } from "./EventEmitter";
+import type { ContentEndpoints, ContentType } from "../types";
 
 // ============================================================================
 // Types
 // ============================================================================
 
-export type GatewayStatus = 'idle' | 'loading' | 'ready' | 'error';
+export type GatewayStatus = "idle" | "loading" | "ready" | "error";
 
 export interface GatewayClientConfig {
   /** Gateway GraphQL endpoint URL */
@@ -45,10 +45,10 @@ const DEFAULT_INITIAL_DELAY_MS = 500;
 // F2: Cache TTL for resolved endpoints
 const DEFAULT_CACHE_TTL_MS = 10000;
 // F3: Circuit breaker constants
-const CIRCUIT_BREAKER_THRESHOLD = 5;       // Open after 5 consecutive failures
-const CIRCUIT_BREAKER_TIMEOUT_MS = 30000;  // Half-open after 30 seconds
+const CIRCUIT_BREAKER_THRESHOLD = 5; // Open after 5 consecutive failures
+const CIRCUIT_BREAKER_TIMEOUT_MS = 30000; // Half-open after 30 seconds
 
-type CircuitBreakerState = 'closed' | 'open' | 'half-open';
+type CircuitBreakerState = "closed" | "open" | "half-open";
 
 const RESOLVE_VIEWER_QUERY = `
   query ResolveViewer($contentId: String!) {
@@ -80,7 +80,7 @@ async function fetchWithRetry(
       const response = await fetch(url, options);
       return response;
     } catch (e) {
-      lastError = e instanceof Error ? e : new Error('Fetch failed');
+      lastError = e instanceof Error ? e : new Error("Fetch failed");
 
       // Don't retry on abort
       if (options.signal?.aborted) {
@@ -91,12 +91,12 @@ async function fetchWithRetry(
       if (attempt < maxRetries - 1) {
         const delay = initialDelay * Math.pow(2, attempt);
         console.warn(`[GatewayClient] Retry ${attempt + 1}/${maxRetries - 1} after ${delay}ms`);
-        await new Promise(resolve => setTimeout(resolve, delay));
+        await new Promise((resolve) => setTimeout(resolve, delay));
       }
     }
   }
 
-  throw lastError ?? new Error('Gateway unreachable after retries');
+  throw lastError ?? new Error("Gateway unreachable after retries");
 }
 
 // ============================================================================
@@ -121,7 +121,7 @@ async function fetchWithRetry(
  */
 export class GatewayClient extends TypedEventEmitter<GatewayClientEvents> {
   private config: GatewayClientConfig;
-  private status: GatewayStatus = 'idle';
+  private status: GatewayStatus = "idle";
   private endpoints: ContentEndpoints | null = null;
   private error: string | null = null;
   private abortController: AbortController | null = null;
@@ -133,7 +133,7 @@ export class GatewayClient extends TypedEventEmitter<GatewayClientEvents> {
   private cacheTtlMs: number;
 
   // F3: Circuit breaker state
-  private circuitState: CircuitBreakerState = 'closed';
+  private circuitState: CircuitBreakerState = "closed";
   private consecutiveFailures = 0;
   private circuitOpenedAt = 0;
 
@@ -159,7 +159,7 @@ export class GatewayClient extends TypedEventEmitter<GatewayClientEvents> {
 
     // F3: Check circuit breaker
     if (!this.canAttemptRequest()) {
-      throw new Error('Circuit breaker is open - too many recent failures');
+      throw new Error("Circuit breaker is open - too many recent failures");
     }
 
     // F2: Return in-flight request if one exists (deduplication)
@@ -214,18 +214,18 @@ export class GatewayClient extends TypedEventEmitter<GatewayClientEvents> {
    */
   private canAttemptRequest(): boolean {
     switch (this.circuitState) {
-      case 'closed':
+      case "closed":
         return true;
 
-      case 'open':
+      case "open":
         // Check if enough time has passed to try half-open
         if (Date.now() - this.circuitOpenedAt >= CIRCUIT_BREAKER_TIMEOUT_MS) {
-          this.circuitState = 'half-open';
+          this.circuitState = "half-open";
           return true;
         }
         return false;
 
-      case 'half-open':
+      case "half-open":
         // Allow one request to test the circuit
         return true;
     }
@@ -236,7 +236,7 @@ export class GatewayClient extends TypedEventEmitter<GatewayClientEvents> {
    */
   private onSuccess(): void {
     this.consecutiveFailures = 0;
-    this.circuitState = 'closed';
+    this.circuitState = "closed";
   }
 
   /**
@@ -245,15 +245,17 @@ export class GatewayClient extends TypedEventEmitter<GatewayClientEvents> {
   private onFailure(): void {
     this.consecutiveFailures++;
 
-    if (this.circuitState === 'half-open') {
+    if (this.circuitState === "half-open") {
       // Failed during half-open - re-open the circuit
-      this.circuitState = 'open';
+      this.circuitState = "open";
       this.circuitOpenedAt = Date.now();
     } else if (this.consecutiveFailures >= CIRCUIT_BREAKER_THRESHOLD) {
       // Threshold reached - open the circuit
-      this.circuitState = 'open';
+      this.circuitState = "open";
       this.circuitOpenedAt = Date.now();
-      console.warn(`[GatewayClient] Circuit breaker opened after ${this.consecutiveFailures} consecutive failures`);
+      console.warn(
+        `[GatewayClient] Circuit breaker opened after ${this.consecutiveFailures} consecutive failures`
+      );
     }
   }
 
@@ -264,7 +266,7 @@ export class GatewayClient extends TypedEventEmitter<GatewayClientEvents> {
     return {
       state: this.circuitState,
       failures: this.consecutiveFailures,
-      openedAt: this.circuitState === 'open' ? this.circuitOpenedAt : null,
+      openedAt: this.circuitState === "open" ? this.circuitOpenedAt : null,
     };
   }
 
@@ -272,7 +274,7 @@ export class GatewayClient extends TypedEventEmitter<GatewayClientEvents> {
    * F3: Manually reset the circuit breaker
    */
   resetCircuitBreaker(): void {
-    this.circuitState = 'closed';
+    this.circuitState = "closed";
     this.consecutiveFailures = 0;
     this.circuitOpenedAt = 0;
   }
@@ -295,25 +297,25 @@ export class GatewayClient extends TypedEventEmitter<GatewayClientEvents> {
 
     // Validate required params
     if (!gatewayUrl || !contentId) {
-      const error = 'Missing required parameters: gatewayUrl or contentId';
-      this.setStatus('error', error);
+      const error = "Missing required parameters: gatewayUrl or contentId";
+      this.setStatus("error", error);
       throw new Error(error);
     }
 
-    this.setStatus('loading');
+    this.setStatus("loading");
 
     const ac = new AbortController();
     this.abortController = ac;
 
     try {
-      const graphqlEndpoint = gatewayUrl.replace(/\/$/, '');
+      const graphqlEndpoint = gatewayUrl.replace(/\/$/, "");
 
       const res = await fetchWithRetry(
         graphqlEndpoint,
         {
-          method: 'POST',
+          method: "POST",
           headers: {
-            'Content-Type': 'application/json',
+            "Content-Type": "application/json",
             ...(authToken ? { Authorization: `Bearer ${authToken}` } : {}),
           },
           body: JSON.stringify({
@@ -333,7 +335,7 @@ export class GatewayClient extends TypedEventEmitter<GatewayClientEvents> {
       const payload = await res.json();
 
       if (payload.errors?.length) {
-        throw new Error(payload.errors[0]?.message || 'GraphQL error');
+        throw new Error(payload.errors[0]?.message || "GraphQL error");
       }
 
       const resp = payload.data?.resolveViewerEndpoint;
@@ -341,7 +343,7 @@ export class GatewayClient extends TypedEventEmitter<GatewayClientEvents> {
       const fallbacks = Array.isArray(resp?.fallbacks) ? resp.fallbacks : [];
 
       if (!primary) {
-        throw new Error('No endpoints available');
+        throw new Error("No endpoints available");
       }
 
       const endpoints: ContentEndpoints = {
@@ -353,19 +355,19 @@ export class GatewayClient extends TypedEventEmitter<GatewayClientEvents> {
       this.endpoints = endpoints;
       // F2: Update cache timestamp
       this.cacheTimestamp = Date.now();
-      this.setStatus('ready');
-      this.emit('endpointsResolved', { endpoints });
+      this.setStatus("ready");
+      this.emit("endpointsResolved", { endpoints });
 
       return endpoints;
     } catch (e) {
       // Ignore abort errors
       if (ac.signal.aborted) {
-        throw new Error('Request aborted');
+        throw new Error("Request aborted");
       }
 
-      const message = e instanceof Error ? e.message : 'Unknown gateway error';
-      console.error('[GatewayClient] Gateway resolution failed:', message);
-      this.setStatus('error', message);
+      const message = e instanceof Error ? e.message : "Unknown gateway error";
+      console.error("[GatewayClient] Gateway resolution failed:", message);
+      this.setStatus("error", message);
       throw new Error(message);
     }
   }
@@ -416,7 +418,7 @@ export class GatewayClient extends TypedEventEmitter<GatewayClientEvents> {
     this.inFlightRequest = null;
     // F3: Reset circuit breaker for new config
     this.resetCircuitBreaker();
-    this.setStatus('idle');
+    this.setStatus("idle");
   }
 
   /**
@@ -430,7 +432,7 @@ export class GatewayClient extends TypedEventEmitter<GatewayClientEvents> {
   private setStatus(status: GatewayStatus, error?: string): void {
     this.status = status;
     this.error = error ?? null;
-    this.emit('statusChange', { status, error });
+    this.emit("statusChange", { status, error });
   }
 }