eb-player 2.0.9 → 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.9";
+    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');
         }
         // -------------------------------------------------------------------------
@@ -6113,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.
          */
@@ -6410,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);