@codenkay/video-nsgplayer-core 0.1.5 → 2.0.0

package/dist/index.js

@@ -146,7 +146,7 @@ var AuthManager = class {
 
 // src/config/defaults.ts
 var PLAYBACK_RATES = [0.5, 0.75, 1, 1.25, 1.5, 2];
-var PACKAGE_VERSION = "0.1.5";
+var PACKAGE_VERSION = "0.1.8";
 var DEFAULT_PLAYER_BEHAVIOR = {
   autoplay: true,
   startMuted: true,
@@ -406,23 +406,25 @@ function isPlainObject2(value) {
   const proto = Object.getPrototypeOf(value);
   return proto === Object.prototype || proto === null;
 }
-function redactValue(key, value, seen = /* @__PURE__ */ new WeakSet(), depth = 0) {
-  if (SENSITIVE_KEYS.test(key)) return "[REDACTED]";
-  if (typeof value === "string") {
-    if (/^https?:\/\//i.test(value) && /[?&](token|expires)=/i.test(value)) {
-      try {
-        const url = new URL(value);
-        for (const param of ["token", "expires", "signature", "sig"]) {
-          if (url.searchParams.has(param)) {
-            url.searchParams.set(param, "[REDACTED]");
-          }
-        }
-        return url.toString();
-      } catch {
-        return "[REDACTED_URL]";
+function redactStringUrl(value) {
+  if (!/^https?:\/\//i.test(value) || !/[?&](token|expires)=/i.test(value)) {
+    return value;
+  }
+  try {
+    const url = new URL(value);
+    for (const param of ["token", "expires", "signature", "sig"]) {
+      if (url.searchParams.has(param)) {
+        url.searchParams.set(param, "[REDACTED]");
       }
     }
+    return url.toString();
+  } catch {
+    return "[REDACTED_URL]";
   }
+}
+function redactValue(key, value, seen = /* @__PURE__ */ new WeakSet(), depth = 0) {
+  if (SENSITIVE_KEYS.test(key)) return "[REDACTED]";
+  if (typeof value === "string") return redactStringUrl(value);
   if (Array.isArray(value)) {
     if (depth >= REDACT_MAX_DEPTH || seen.has(value)) return "[REDACTED_CYCLE]";
     seen.add(value);
@@ -689,10 +691,11 @@ var RefreshManager = class {
       this.options.logger.debug("Playback source renewed", { reason });
     } catch (error) {
       this.consecutiveFailures += 1;
-      const message = error instanceof Error ? error.message : "Playback refresh failed";
+      const message = refreshErrorMessage(error);
       this.options.logger.warn("Playback refresh failed", {
         reason,
-        failure: this.consecutiveFailures
+        failure: this.consecutiveFailures,
+        message
       });
       if (this.consecutiveFailures >= this.options.renewMaxRetries) {
         this.options.onFatal?.(message);
@@ -712,6 +715,13 @@ var RefreshManager = class {
     }
   }
 };
+function refreshErrorMessage(error) {
+  if (error instanceof Error && error.message) return error.message;
+  if (error && typeof error === "object" && "message" in error && typeof error.message === "string" && error.message) {
+    return error.message;
+  }
+  return "Playback refresh failed";
+}
 
 // src/playback/liveEdge.ts
 var DEFAULT_LIVE_EDGE_TOLERANCE_SECONDS = 3;
@@ -755,7 +765,9 @@ function seekToLiveEdge(media, options) {
 }
 
 // src/streaming/authParamsLoader.ts
+import { XhrLoader as BuiltinXhrLoader } from "hls.js";
 var ENC_KEY_PATH_RE = /enc\.key$/i;
+var BUILTIN_LOADER_NAMES = /* @__PURE__ */ new Set(["XhrLoader", "FetchLoader"]);
 function isEncryptionKeyUrl(rawUrl, baseOrigin = typeof location !== "undefined" ? location.origin : "http://localhost") {
   try {
     return ENC_KEY_PATH_RE.test(new URL(rawUrl, baseOrigin).pathname);
@@ -763,6 +775,27 @@ function isEncryptionKeyUrl(rawUrl, baseOrigin = typeof location !== "undefined"
     return /enc\.key/i.test(rawUrl);
   }
 }
+function resolveBuiltinHlsLoader(HlsClass) {
+  if (typeof BuiltinXhrLoader === "function") {
+    return BuiltinXhrLoader;
+  }
+  const start = HlsClass.DefaultConfig.loader;
+  let current = start;
+  const seen = /* @__PURE__ */ new Set();
+  while (current && !seen.has(current)) {
+    seen.add(current);
+    const name = typeof current.name === "string" ? current.name : "";
+    if (BUILTIN_LOADER_NAMES.has(name)) {
+      return current;
+    }
+    const parentCtor = Object.getPrototypeOf(current.prototype)?.constructor;
+    if (!parentCtor || parentCtor === Object || parentCtor === Function) {
+      break;
+    }
+    current = parentCtor;
+  }
+  return start;
+}
 function rewriteHlsRequestUrl(rawUrl, store, options = {}, baseOrigin = typeof location !== "undefined" ? location.origin : "http://localhost") {
   if (!rawUrl) return rawUrl;
   const parsed = new URL(rawUrl, baseOrigin);
@@ -781,28 +814,145 @@ function rewriteHlsRequestUrl(rawUrl, store, options = {}, baseOrigin = typeof l
   if (!store.hasParams()) return parsed.toString();
   return store.applyToUrl(rawUrl, baseOrigin);
 }
+function createLoaderStats() {
+  const now = performance.now();
+  return {
+    aborted: false,
+    loaded: 0,
+    retry: 0,
+    total: 0,
+    chunkCount: 0,
+    bwEstimate: 0,
+    loading: { start: now, first: 0, end: 0 },
+    parsing: { start: 0, end: 0 },
+    buffering: { start: 0, first: 0, end: 0 }
+  };
+}
+async function loadEncryptionKeyWithFetch(context, callbacks, accessToken, signal) {
+  const stats = createLoaderStats();
+  stats.loading.first = performance.now();
+  const headers = {
+    Accept: "*/*",
+    ...context.headers
+  };
+  if (accessToken) {
+    headers.Authorization = `Bearer ${accessToken}`;
+  }
+  const response = await fetch(context.url, {
+    method: "GET",
+    headers,
+    credentials: "omit",
+    cache: "no-store",
+    signal
+  });
+  if (!response.ok) {
+    callbacks.onError(
+      {
+        code: response.status,
+        text: response.statusText || `enc.key HTTP ${response.status}`
+      },
+      context,
+      response,
+      stats
+    );
+    return;
+  }
+  const data = await response.arrayBuffer();
+  const end = performance.now();
+  stats.loading.end = end;
+  stats.loaded = data.byteLength;
+  stats.total = data.byteLength;
+  const head = new TextDecoder().decode(data.slice(0, 32));
+  if (/<!DOCTYPE|<html/i.test(head)) {
+    callbacks.onError(
+      {
+        code: 403,
+        text: "enc.key returned HTML (CDN challenge/block), not an AES key"
+      },
+      context,
+      response,
+      stats
+    );
+    return;
+  }
+  callbacks.onSuccess(
+    {
+      url: response.url || context.url,
+      data,
+      code: response.status
+    },
+    stats,
+    context,
+    response
+  );
+}
 function createAuthParamsLoader(HlsClass, store, options = {}) {
-  const BaseLoader = HlsClass.DefaultConfig.loader;
-  return class AuthParamsLoader extends BaseLoader {
+  const BaseLoader = resolveBuiltinHlsLoader(HlsClass);
+  return class AuthParamsLoader {
+    constructor(config) {
+      this.keyAbort = null;
+      this.inner = new BaseLoader(config);
+      this.stats = this.inner.stats;
+    }
+    abort() {
+      this.keyAbort?.abort();
+      this.keyAbort = null;
+      this.inner.abort?.();
+    }
+    destroy() {
+      this.keyAbort?.abort();
+      this.keyAbort = null;
+      this.inner.destroy();
+    }
     load(context, config, callbacks) {
-      if (context.url) {
-        try {
-          const originalUrl = context.url;
-          const isKey = isEncryptionKeyUrl(originalUrl);
-          context.url = rewriteHlsRequestUrl(originalUrl, store, options);
-          if (isKey && !options.keyProxyUrlBuilder && options.getKeyAccessToken) {
-            const accessToken = options.getKeyAccessToken();
-            if (accessToken) {
-              context.headers = {
-                ...context.headers ?? {},
-                Authorization: `Bearer ${accessToken}`
-              };
-            }
+      if (!context.url) {
+        this.inner.load(context, config, callbacks);
+        return;
+      }
+      try {
+        const originalUrl = context.url;
+        const isKey = isEncryptionKeyUrl(originalUrl);
+        const usingKeyProxy = Boolean(
+          isKey && options.keyProxyUrlBuilder && options.videoId
+        );
+        context.url = rewriteHlsRequestUrl(originalUrl, store, options);
+        if (usingKeyProxy) {
+          this.inner.load(context, config, callbacks);
+          return;
+        }
+        if (isKey && typeof options.getKeyAccessToken === "function") {
+          const accessToken = options.getKeyAccessToken() ?? null;
+          if (accessToken) {
+            this.keyAbort?.abort();
+            this.keyAbort = new AbortController();
+            const timeoutMs = typeof config?.timeout === "number" && config.timeout > 0 ? config.timeout : 2e4;
+            const timer = setTimeout(() => this.keyAbort?.abort(), timeoutMs);
+            void loadEncryptionKeyWithFetch(
+              context,
+              callbacks,
+              accessToken,
+              this.keyAbort.signal
+            ).catch((error) => {
+              const stats = createLoaderStats();
+              const aborted = error instanceof DOMException && error.name === "AbortError";
+              callbacks.onError(
+                {
+                  code: 0,
+                  text: aborted ? "enc.key fetch aborted/timeout" : error instanceof Error ? error.message : "enc.key fetch failed"
+                },
+                context,
+                null,
+                stats
+              );
+            }).finally(() => {
+              clearTimeout(timer);
+            });
+            return;
           }
-        } catch {
         }
+      } catch {
       }
-      super.load(context, config, callbacks);
+      this.inner.load(context, config, callbacks);
     }
   };
 }
@@ -821,6 +971,11 @@ var HlsEngine = class {
     this.mediaRecoveryCount = 0;
     this.qualities = [];
     this.qualitySelection = "auto";
+    this.textTracks = [];
+    this.textTrackSelection = "off";
+    this.audioTracks = [];
+    this.audioTrackSelection = 0;
+    this.nativeTextTrackCleanup = null;
   }
   async start() {
     const { videoEl, playbackUrl, startMuted, volume } = this.options;
@@ -840,6 +995,7 @@ var HlsEngine = class {
       this.options.callbacks.onSupportMode?.("native");
       videoEl.src = this.options.authParams.applyToUrl(playbackUrl);
       this.bindMediaEvents();
+      this.bindNativeTextTracks();
       this.options.callbacks.onStateChange?.("ready");
       await this.applyStartPositionAndAutoplay();
       return;
@@ -883,9 +1039,19 @@ var HlsEngine = class {
         label: level.height != null && level.height > 0 ? `${level.height}p` : `Level ${index}`
       }));
       callbacks.onQualitiesChange?.(this.qualities);
+      this.syncHlsSubtitleTracks();
+      this.syncHlsAudioTracks();
       callbacks.onStateChange?.("ready");
       void this.applyStartPositionAndAutoplay();
     });
+    this.hls.on(Hls.Events.SUBTITLE_TRACKS_UPDATED, () => {
+      if (this.destroyed) return;
+      this.syncHlsSubtitleTracks();
+    });
+    this.hls.on(Hls.Events.AUDIO_TRACKS_UPDATED, () => {
+      if (this.destroyed) return;
+      this.syncHlsAudioTracks();
+    });
     this.hls.on(Hls.Events.ERROR, (_event, data) => {
       this.handleHlsError(Hls, data);
     });
@@ -893,19 +1059,24 @@ var HlsEngine = class {
   }
   handleHlsError(Hls, data) {
     if (this.destroyed) return;
-    const { callbacks, hlsConfig, keyProxyUrlBuilder, getKeyAccessToken } = this.options;
+    const { callbacks, hlsConfig } = this.options;
     const status = data.response?.code;
-    if (data.details === Hls.ErrorDetails.KEY_LOAD_ERROR && !keyProxyUrlBuilder && !getKeyAccessToken) {
-      callbacks.onFatalError?.(
-        "Encryption key load failed. Configure streaming.getKeyAccessToken (browser Bearer) or streaming.keyProxyUrlBuilder (Cloudflare-allowlisted BFF) for Appextech AES-encrypted HLS."
-      );
-      return;
+    const authFailure = isAuthHttpStatus(status);
+    if (data.details === Hls.ErrorDetails.KEY_LOAD_ERROR) {
+      if (authFailure) {
+        callbacks.onAuthRecoveryNeeded?.("key_error");
+        if (!data.fatal) return;
+      } else if (!data.fatal) {
+        callbacks.onFatalError?.(
+          status ? `Encryption key load failed (HTTP ${status}).` : "Encryption key load failed (network/CORS). Ensure signed query params are applied, or use keyProxyUrlBuilder / getKeyAccessToken when the key host requires API Bearer."
+        );
+        return;
+      }
     }
-    const authFailure = isAuthHttpStatus(status) || data.details === Hls.ErrorDetails.KEY_LOAD_ERROR && (status === void 0 || status === 0 || isAuthHttpStatus(status));
     if (!data.fatal) {
-      if (authFailure && data.type === Hls.ErrorTypes.NETWORK_ERROR && (data.details === Hls.ErrorDetails.FRAG_LOAD_ERROR || data.details === Hls.ErrorDetails.LEVEL_LOAD_ERROR || data.details === Hls.ErrorDetails.KEY_LOAD_ERROR)) {
+      if (authFailure && data.type === Hls.ErrorTypes.NETWORK_ERROR && (data.details === Hls.ErrorDetails.FRAG_LOAD_ERROR || data.details === Hls.ErrorDetails.LEVEL_LOAD_ERROR)) {
         callbacks.onAuthRecoveryNeeded?.(
-          data.details === Hls.ErrorDetails.KEY_LOAD_ERROR ? "key_error" : data.details === Hls.ErrorDetails.LEVEL_LOAD_ERROR ? "level_error" : "frag_error"
+          data.details === Hls.ErrorDetails.LEVEL_LOAD_ERROR ? "level_error" : "frag_error"
         );
       }
       return;
@@ -1006,12 +1177,120 @@ var HlsEngine = class {
   getQualities() {
     return this.qualities;
   }
+  getTextTracks() {
+    return this.textTracks;
+  }
+  getTextTrackSelection() {
+    return this.textTrackSelection;
+  }
+  setTextTrack(selection) {
+    if (this.destroyed) return;
+    this.textTrackSelection = selection;
+    this.options.callbacks.onTextTrackSelectionChange?.(selection);
+    if (this.supportMode === "hls.js" && this.hls) {
+      this.hls.subtitleDisplay = selection !== "off";
+      this.hls.subtitleTrack = selection === "off" ? -1 : selection;
+      return;
+    }
+    if (this.supportMode === "native" && this.options.videoEl) {
+      const tracks = this.options.videoEl.textTracks;
+      for (let i = 0; i < tracks.length; i += 1) {
+        const track = tracks[i];
+        track.mode = selection !== "off" && i === selection ? "showing" : "disabled";
+      }
+    }
+  }
+  getAudioTracks() {
+    return this.audioTracks;
+  }
+  getAudioTrackSelection() {
+    return this.audioTrackSelection;
+  }
+  setAudioTrack(index) {
+    if (this.destroyed) return;
+    if (!Number.isInteger(index) || index < 0 || this.audioTracks.length > 0 && index >= this.audioTracks.length) {
+      return;
+    }
+    this.audioTrackSelection = index;
+    this.options.callbacks.onAudioTrackSelectionChange?.(index);
+    if (this.supportMode === "hls.js" && this.hls) {
+      this.hls.audioTrack = index;
+      return;
+    }
+    if (this.supportMode === "native" && this.options.videoEl) {
+      const audioTracks = this.options.videoEl.audioTracks;
+      if (audioTracks && audioTracks.length > 0) {
+        for (let i = 0; i < audioTracks.length; i += 1) {
+          audioTracks[i].enabled = i === index;
+        }
+      }
+    }
+  }
   getSupportMode() {
     return this.supportMode;
   }
+  syncHlsSubtitleTracks() {
+    if (!this.hls) return;
+    const tracks = (this.hls.subtitleTracks ?? []).map(
+      (track, index) => ({
+        index,
+        id: String(track.id ?? index),
+        label: track.name || track.lang || `Subtitles ${index + 1}`,
+        language: track.lang
+      })
+    );
+    this.textTracks = tracks;
+    this.options.callbacks.onTextTracksChange?.(tracks);
+  }
+  syncHlsAudioTracks() {
+    if (!this.hls) return;
+    const tracks = (this.hls.audioTracks ?? []).map(
+      (track, index) => ({
+        index,
+        id: String(track.id ?? index),
+        label: track.name || track.lang || `Audio ${index + 1}`,
+        language: track.lang
+      })
+    );
+    this.audioTracks = tracks;
+    this.options.callbacks.onAudioTracksChange?.(tracks);
+    if (tracks.length > 0) {
+      this.audioTrackSelection = 0;
+      this.options.callbacks.onAudioTrackSelectionChange?.(0);
+    }
+  }
+  bindNativeTextTracks() {
+    const { videoEl } = this.options;
+    const syncFromElement = () => {
+      if (this.destroyed || this.textTracks.length > 0) return;
+      const list = videoEl.textTracks;
+      const tracks = [];
+      for (let i = 0; i < list.length; i += 1) {
+        const track = list[i];
+        if (track.kind !== "subtitles" && track.kind !== "captions") continue;
+        tracks.push({
+          index: tracks.length,
+          id: track.id || `native-${tracks.length}`,
+          label: track.label || track.language || `Track ${tracks.length + 1}`,
+          language: track.language || void 0
+        });
+      }
+      if (tracks.length === 0) return;
+      this.textTracks = tracks;
+      this.options.callbacks.onTextTracksChange?.(tracks);
+    };
+    const textTracks = videoEl.textTracks;
+    textTracks.addEventListener?.("addtrack", syncFromElement);
+    syncFromElement();
+    this.nativeTextTrackCleanup = () => {
+      textTracks.removeEventListener?.("addtrack", syncFromElement);
+    };
+  }
   destroy() {
     if (this.destroyed) return;
     this.destroyed = true;
+    this.nativeTextTrackCleanup?.();
+    this.nativeTextTrackCleanup = null;
     this.hls?.destroy();
     this.hls = null;
     const { videoEl } = this.options;
@@ -1068,11 +1347,40 @@ function createVideoPlayer(options) {
   let refreshManager = null;
   let fullscreenEl = null;
   let isLiveStream = false;
+  let mediaCleanup = null;
   const setState = (next) => {
     if (destroyed && next !== "destroyed") return;
     state = next;
     events.emit("statechange", { state: next });
   };
+  const bindMediaProgressEvents = (el) => {
+    mediaCleanup?.();
+    const onTimeUpdate = () => {
+      if (destroyed) return;
+      events.emit("timeupdate", {
+        currentTime: el.currentTime,
+        duration: Number.isFinite(el.duration) ? el.duration : 0
+      });
+    };
+    const onProgress = () => {
+      if (destroyed) return;
+      let bufferedEnd = 0;
+      try {
+        if (el.buffered.length > 0) {
+          bufferedEnd = el.buffered.end(el.buffered.length - 1);
+        }
+      } catch {
+        bufferedEnd = 0;
+      }
+      events.emit("progress", { bufferedEnd });
+    };
+    el.addEventListener("timeupdate", onTimeUpdate);
+    el.addEventListener("progress", onProgress);
+    mediaCleanup = () => {
+      el.removeEventListener("timeupdate", onTimeUpdate);
+      el.removeEventListener("progress", onProgress);
+    };
+  };
   const authManager = new AuthManager(
     options.auth,
     options.auth?.refreshBeforeExpiryMs ?? 6e4,
@@ -1123,6 +1431,7 @@ function createVideoPlayer(options) {
         isLiveStream = Boolean(source.live);
       }
       const el = ensureVideoElement();
+      bindMediaProgressEvents(el);
       engine?.destroy();
       engine = new HlsEngine({
         videoEl: el,
@@ -1134,6 +1443,11 @@ function createVideoPlayer(options) {
         volume: config.player.volume,
         videoId: options.videoId,
         keyProxyUrlBuilder: config.streaming.keyProxyUrlBuilder,
+        // Optional: browser Bearer for Video API–origin enc.key (CORS-dependent).
+        // CDN keys use signed query via the auth loader (no Bearer) — same as
+        // segments. Apps can pass getKeyAccessToken or rely on keyProxyUrlBuilder.
+        // When unset, defaults to AuthManager token only if explicitly requested
+        // via streaming.getKeyAccessToken; otherwise query-signed XHR.
         getKeyAccessToken: config.streaming.getKeyAccessToken,
         hlsConfig: config.streaming.hls,
         logger,
@@ -1176,6 +1490,30 @@ function createVideoPlayer(options) {
               label: typeof selection === "number" ? level?.label : "auto"
             });
           },
+          onTextTracksChange: (tracks) => {
+            events.emit("texttrackchange", {
+              tracks,
+              selection: engine?.getTextTrackSelection() ?? "off"
+            });
+          },
+          onTextTrackSelectionChange: (selection) => {
+            events.emit("texttrackchange", {
+              tracks: engine?.getTextTracks() ?? [],
+              selection
+            });
+          },
+          onAudioTracksChange: (tracks) => {
+            events.emit("audiotrackchange", {
+              tracks,
+              selection: engine?.getAudioTrackSelection() ?? 0
+            });
+          },
+          onAudioTrackSelectionChange: (selection) => {
+            events.emit("audiotrackchange", {
+              tracks: engine?.getAudioTracks() ?? [],
+              selection
+            });
+          },
           onEnded: () => events.emit("ended")
         }
       });
@@ -1334,6 +1672,24 @@ function createVideoPlayer(options) {
     getAvailableQualities() {
       return engine?.getQualities() ?? [];
     },
+    getTextTracks() {
+      return engine?.getTextTracks() ?? [];
+    },
+    getSelectedTextTrack() {
+      return engine?.getTextTrackSelection() ?? "off";
+    },
+    setTextTrack(selection) {
+      engine?.setTextTrack(selection);
+    },
+    getAudioTracks() {
+      return engine?.getAudioTracks() ?? [];
+    },
+    getSelectedAudioTrack() {
+      return engine?.getAudioTrackSelection() ?? 0;
+    },
+    setAudioTrack(index) {
+      engine?.setAudioTrack(index);
+    },
     async enterFullscreen() {
       const target = fullscreenEl ?? videoEl?.parentElement ?? videoEl;
       if (target && "requestFullscreen" in target) {
@@ -1350,6 +1706,9 @@ function createVideoPlayer(options) {
     isFullscreen() {
       return Boolean(document.fullscreenElement);
     },
+    setFullscreenElement(el) {
+      fullscreenEl = el;
+    },
     async reload() {
       refreshManager?.stop();
       engine?.destroy();
@@ -1358,6 +1717,8 @@ function createVideoPlayer(options) {
     destroy() {
       if (destroyed) return;
       destroyed = true;
+      mediaCleanup?.();
+      mediaCleanup = null;
       refreshManager?.stop();
       refreshManager = null;
       engine?.destroy();
@@ -1448,11 +1809,13 @@ export {
   createVideoPlayer,
   getLiveEdgeTime,
   isAtLiveEdge,
+  isEncryptionKeyUrl,
   isPlainObject,
   mergePlayerConfig,
   redactObject,
   redactSensitive,
   redactValue,
+  resolveBuiltinHlsLoader,
   rewriteHlsRequestUrl,
   seekToLiveEdge,
   themeToCssVars