eb-player 2.0.8 → 2.0.10

package/dist/build/ebplayer.bundle.js

@@ -4,7 +4,7 @@
     (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.EBPlayer = {}));
 })(this, (function (exports) { 'use strict';
 
-    var __EB_PLAYER_VERSION__ = "2.0.7";
+    var __EB_PLAYER_VERSION__ = "2.0.10";
 
     /**
      * Finite State Machine for player playback state transitions.
@@ -4487,6 +4487,7 @@
             this.expirationMarginInSeconds = expirationMarginInSeconds;
             this.lastTokenResponse = null;
             this.resetAttemptCounterTimeout = null;
+            this.inFlightFetch = null;
         }
         resetAttemptCounter() {
             if (this.resetAttemptCounterTimeout) {
@@ -4730,21 +4731,35 @@
                 console.warn('CDNToken: Missing src to tokenize');
                 return null;
             }
-            switch (this.tokenType) {
-                case TOKEN_TYPES.BUNNY:
-                    this.lastTokenResponse = await this._fetchBunnyToken(src);
-                    break;
-                case TOKEN_TYPES.AKAMAI:
-                    this.lastTokenResponse = await this._fetchAkamaiToken(src);
-                    break;
-                case TOKEN_TYPES.VENOM:
-                case TOKEN_TYPES.EASY_B:
-                    this.lastTokenResponse = await this._fetchEasyBToken(src);
-                    break;
-                default:
-                    this.lastTokenResponse = await this._fetchDefaultToken(src);
+            // Deduplicate concurrent fetches: if a fetch is already in flight,
+            // return the same promise instead of firing a second network request.
+            // This prevents the main player and snapshot handler from both triggering
+            // separate generate calls when their manifest refreshes overlap.
+            if (this.inFlightFetch) {
+                return this.inFlightFetch;
             }
-            return this.lastTokenResponse;
+            const doFetch = async () => {
+                switch (this.tokenType) {
+                    case TOKEN_TYPES.BUNNY:
+                        return this._fetchBunnyToken(src);
+                    case TOKEN_TYPES.AKAMAI:
+                        return this._fetchAkamaiToken(src);
+                    case TOKEN_TYPES.VENOM:
+                    case TOKEN_TYPES.EASY_B:
+                        return this._fetchEasyBToken(src);
+                    default:
+                        return this._fetchDefaultToken(src);
+                }
+            };
+            this.inFlightFetch = doFetch().then((response) => {
+                this.lastTokenResponse = response;
+                this.inFlightFetch = null;
+                return response;
+            }).catch((error) => {
+                this.inFlightFetch = null;
+                throw error;
+            });
+            return this.inFlightFetch;
         }
         // -------------------------------------------------------------------------
         // Public: updateUrlWithTokenParams
@@ -4847,6 +4862,7 @@
             }
             this.attempt = 0;
             this.lastTokenResponse = null;
+            this.inFlightFetch = null;
             console.log('CDNTokenManager: destroyed');
         }
         // -------------------------------------------------------------------------
@@ -5244,7 +5260,9 @@
             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,
@@ -5253,13 +5271,6 @@
                     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');
@@ -5342,7 +5353,6 @@
             // 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
@@ -5365,8 +5375,27 @@
                 }
             }
             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();
         }
@@ -6100,6 +6129,24 @@
         getVideo() {
             return this.offscreenVideo;
         }
+        /**
+         * Stop manifest refreshes (and thus CDN token requests) while the main player is paused.
+         * For live streams, the snapshot hls.js instance continuously refreshes the manifest
+         * on the playlist interval — this prevents unnecessary generate calls during pause.
+         */
+        stopLoad() {
+            if (this.driver && typeof this.driver['stopLoad'] === 'function') {
+                this.driver['stopLoad']();
+            }
+        }
+        /**
+         * Resume manifest refreshes when the main player resumes playback.
+         */
+        startLoad() {
+            if (this.driver && typeof this.driver['startLoad'] === 'function') {
+                this.driver['startLoad'](-1);
+            }
+        }
         /**
          * Destroy the snapshot Hls instance and clean up resources.
          */
@@ -6397,6 +6444,21 @@
                                     if (snapshotVideo !== null) {
                                         controller.bus.emit('snapshot-handler-ready', { take: (time) => handler.take(time), video: snapshotVideo });
                                     }
+                                    // Stop/start snapshot manifest refreshes on pause/play to prevent
+                                    // CDN token generate calls while the player is paused (live streams only).
+                                    // Mirrors the same logic in hls.ts for the main engine.
+                                    if (video) {
+                                        video.addEventListener('pause', () => {
+                                            if (controller.state?.isLive) {
+                                                handler.stopLoad();
+                                            }
+                                        }, { signal: controller.signal });
+                                        video.addEventListener('play', () => {
+                                            if (controller.state?.isLive) {
+                                                setTimeout(() => handler.startLoad(), 0);
+                                            }
+                                        }, { signal: controller.signal });
+                                    }
                                 })
                                     .catch((error) => {
                                     console.warn('EBPlayer: HlsSnapshotHandler init failed:', error);