eb-player 2.0.7 → 2.0.9

package/dist/dev/easybroadcast.js

@@ -1,7 +1,7 @@
 var EBPlayerBundle = (function (exports) {
   'use strict';
 
-  var __EB_PLAYER_VERSION__ = "2.0.6";
+  var __EB_PLAYER_VERSION__ = "2.0.9";
 
   function styleInject(css, ref) {
     if ( ref === void 0 ) ref = {};
@@ -4332,6 +4332,15 @@ var EBPlayerBundle = (function (exports) {
           video.addEventListener('ended', () => {
               state.playbackState = 'ended';
           }, { signal });
+          // Safety net: clear stale 'buffering' state when playback is clearly advancing.
+          // In some edge cases (live stream segment boundaries), the browser fires 'waiting'
+          // but never fires 'playing' even though video resumes from buffer. The timeupdate
+          // event fires reliably while time advances, so we use it to recover.
+          video.addEventListener('timeupdate', () => {
+              if (state.playbackState === 'buffering' && !video.paused && video.readyState >= 3) {
+                  state.playbackState = 'playing';
+              }
+          }, { signal });
       }
       /**
        * Seek to a specific time. Default implementation sets video.currentTime.
@@ -5160,6 +5169,14 @@ var EBPlayerBundle = (function (exports) {
       getDriver() {
           return this.driver;
       }
+      /**
+       * Returns the CDN token manager used by this engine.
+       * Allows the snapshot handler to share the same manager (avoids duplicate token requests).
+       * Returns null when no token URL is configured or before init().
+       */
+      getTokenManager() {
+          return this.tokenManager;
+      }
       // -------------------------------------------------------------------------
       // BaseEngine hooks
       // -------------------------------------------------------------------------
@@ -5275,7 +5292,9 @@ var EBPlayerBundle = (function (exports) {
           if (!hlsjsUrl) {
               throw new Error('HlsEngine: config.hlsjs URL is required');
           }
-          // Create token manager if a token URL is configured
+          // Create token manager if a token URL is configured.
+          // No initial fetchToken() here — updateUrlWithTokenParams() below handles it
+          // and populates lastTokenResponse (used lazily by DRM licenseXhrSetup).
           if (config.token) {
               this.tokenManager = new CDNTokenManager({
                   token: config.token,
@@ -5284,13 +5303,6 @@ var EBPlayerBundle = (function (exports) {
                   extraParamsCallback: (config.engineSettings.extraParamsCallback ?? config.extraParamsCallback),
                   onCDNTokenError: config.engineSettings.onCDNTokenError
               });
-              // Fetch initial token
-              if (config.src) {
-                  await this.tokenManager.fetchToken({ src: config.src });
-              }
-              // Guard: abort if detached during token fetch
-              if (this.detached)
-                  return;
           }
           // console.info('HlsEngine: loading hls.js from', hlsjsUrl)
           const Hls = await loadScript(hlsjsUrl, 'Hls');
@@ -5373,7 +5385,6 @@ var EBPlayerBundle = (function (exports) {
           // Create the driver (NEVER stored in state)
           const driver = new Hls(driverConfig);
           this.driver = driver;
-          this.resolveDriverReady();
           // Pitfall 4: apply discontinuity workaround BEFORE attachMedia/loadSource
           applyDiscontinuityWorkaround(driver, Hls.Events);
           // Wire retry handler
@@ -5396,8 +5407,27 @@ var EBPlayerBundle = (function (exports) {
               }
           }
           driver.loadSource(src);
+          // Resolve driverReady AFTER loadSource so consumers (P2P, snapshot handler)
+          // don't start making token requests before the main engine's initial token
+          // fetch completes and populates the cache.
+          this.resolveDriverReady();
           // Register driver event handlers
           this.registerDriverEvents(Hls, state);
+          // Pause/resume loading on video pause/play to stop manifest refreshes
+          // (and thus CDN token requests) while the player is paused.
+          // Only applies to live streams where hls.js continuously refreshes the manifest.
+          const driverRef = driver;
+          video.addEventListener('pause', () => {
+              if (this.state?.isLive) {
+                  driverRef.stopLoad();
+              }
+          }, { signal });
+          video.addEventListener('play', () => {
+              if (this.state?.isLive) {
+                  // Defer startLoad to avoid re-entrancy (Pitfall 3)
+                  setTimeout(() => driverRef.startLoad(-1), 0);
+              }
+          }, { signal });
           // Start stall watchdog
           this.startWatchdog();
       }
@@ -6414,30 +6444,14 @@ var EBPlayerBundle = (function (exports) {
                       else {
                           const win = window;
                           if (win.Hls) {
-                              // Create a dedicated token manager for the snapshot handler (DRM license + manifest tokens)
-                              let snapshotTokenManager = null;
-                              if (mergedConfig.token) {
-                                  snapshotTokenManager = new CDNTokenManager({
-                                      token: mergedConfig.token,
-                                      tokenType: mergedConfig.tokenType,
-                                      srcInTokenRequest: mergedConfig.srcInTokenRequest,
-                                      extraParamsCallback: (mergedConfig.engineSettings.extraParamsCallback ?? mergedConfig.extraParamsCallback),
-                                      onCDNTokenError: mergedConfig.engineSettings.onCDNTokenError
-                                  });
-                              }
+                              // Share the main engine's token manager with the snapshot handler
+                              // to avoid duplicate token requests (one CDNTokenManager per player instance)
+                              const sharedTokenManager = engine.getTokenManager();
                               // Build DRM config (emeEnabled, drmSystems, licenseXhrSetup) for the snapshot hls.js instance
-                              const snapshotDrmConfigurator = new DrmConfigurator(snapshotTokenManager);
+                              const snapshotDrmConfigurator = new DrmConfigurator(sharedTokenManager);
                               const snapshotDrmConfig = snapshotDrmConfigurator.buildHlsConfig(mergedConfig.engineSettings);
-                              const handler = new HlsSnapshotHandler({ src, engineSettings: { ...mergedConfig.engineSettings, ...snapshotDrmConfig } }, snapshotTokenManager);
-                              // Fetch initial token before init (needed for manifest request)
-                              const tokenReady = snapshotTokenManager && src
-                                  ? snapshotTokenManager.fetchToken({ src }).catch((error) => {
-                                      console.warn('EBPlayer: Snapshot token fetch failed:', error);
-                                  })
-                                  : Promise.resolve();
-                              tokenReady.then(() => {
-                                  return handler.init(win.Hls);
-                              })
+                              const handler = new HlsSnapshotHandler({ src, engineSettings: { ...mergedConfig.engineSettings, ...snapshotDrmConfig } }, sharedTokenManager);
+                              handler.init(win.Hls)
                                   .then(() => {
                                   activeSnapshotDestroy = () => handler.destroy();
                                   const snapshotVideo = handler.getVideo();
@@ -6494,9 +6508,22 @@ var EBPlayerBundle = (function (exports) {
           }, 100);
       });
       // Auto-open the stream if src is provided in config (matches legacy player behaviour
-      // where consumers call start({ src: '...' }) and expect playback to begin immediately)
+      // where consumers call start({ src: '...' }) and expect playback to begin immediately).
+      // When autoplay is false, defer open() until the user requests play — this avoids
+      // fetching CDN tokens and loading manifests before playback is actually needed.
       if (mergedConfig.src) {
-          reference.open(mergedConfig.src);
+          if (mergedConfig.autoplay) {
+              reference.open(mergedConfig.src);
+          }
+          else {
+              let deferredOpen = true;
+              controller.bus.on('play', () => {
+                  if (deferredOpen) {
+                      deferredOpen = false;
+                      reference.open(mergedConfig.src);
+                  }
+              }, { signal: controller.signal });
+          }
       }
       return reference;
   }