eb-player 2.0.9 → 2.0.11

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.11";
 
     /**
      * Finite State Machine for player playback state transitions.
@@ -4284,12 +4284,20 @@
             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.
+            // Safety net: reconcile stale FSM state when playback is clearly advancing.
+            // Covers two scenarios:
+            // 1. Live stream segment boundaries where browser fires 'waiting' but never
+            //    fires 'playing' even though video resumes from buffer.
+            // 2. Safari autoplay: when the browser starts playback via the autoplay attribute,
+            //    the 'playing' event can be missed or arrive out of order, leaving the FSM
+            //    stuck in 'loading' or 'buffering' while the video is actually playing.
+            // The timeupdate event fires reliably while time advances, so we use it to recover.
+            // Note: Safari with MSE/hls.js may report readyState=2 (HAVE_CURRENT_DATA) even
+            // while actively playing and advancing currentTime. We don't gate on readyState
+            // here — the fact that timeupdate fires with !paused is sufficient proof of playback.
             video.addEventListener('timeupdate', () => {
-                if (state.playbackState === 'buffering' && !video.paused && video.readyState >= 3) {
+                const stuck = state.playbackState === 'buffering' || state.playbackState === 'loading';
+                if (stuck && !video.paused) {
                     state.playbackState = 'playing';
                 }
             }, { signal });
@@ -4487,6 +4495,7 @@
             this.expirationMarginInSeconds = expirationMarginInSeconds;
             this.lastTokenResponse = null;
             this.resetAttemptCounterTimeout = null;
+            this.inFlightFetch = null;
         }
         resetAttemptCounter() {
             if (this.resetAttemptCounterTimeout) {
@@ -4730,21 +4739,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 +4870,7 @@
             }
             this.attempt = 0;
             this.lastTokenResponse = null;
+            this.inFlightFetch = null;
             console.log('CDNTokenManager: destroyed');
         }
         // -------------------------------------------------------------------------
@@ -5382,6 +5406,39 @@
             }, { signal });
             // Start stall watchdog
             this.startWatchdog();
+            // Post-init state reconciliation: during the async init() above, the browser
+            // may have started or blocked playback in ways that leave the FSM out of sync.
+            // Two cases:
+            //   A) Video is playing but FSM missed the 'playing' event (Safari event ordering)
+            //   B) Autoplay was blocked — Safari fires 'waiting' (→ buffering) but may not
+            //      fire 'pause', leaving the spinner visible over a paused video
+            // A short periodic check covers both cases and self-cleans after convergence.
+            const reconcileVideo = video;
+            const reconcileState = state;
+            let reconcileCount = 0;
+            const reconcileTimer = setInterval(() => {
+                reconcileCount++;
+                if (reconcileCount >= 10) {
+                    clearInterval(reconcileTimer);
+                    return;
+                }
+                const fsm = reconcileState.playbackState;
+                // Case A: video is playing but FSM disagrees
+                // Note: Safari/MSE may report readyState=2 while actively playing, so we
+                // check currentTime advancement instead of readyState >= 3.
+                if (fsm !== 'playing' && !reconcileVideo.paused && reconcileVideo.currentTime > 0) {
+                    reconcileState.playbackState = 'playing';
+                    clearInterval(reconcileTimer);
+                    return;
+                }
+                // Case B: autoplay blocked — video is paused but FSM stuck in buffering/loading
+                if ((fsm === 'buffering' || fsm === 'loading') && reconcileVideo.paused) {
+                    reconcileState.playbackState = 'paused';
+                    clearInterval(reconcileTimer);
+                }
+            }, 200);
+            // Clean up on engine detach
+            signal.addEventListener('abort', () => clearInterval(reconcileTimer), { once: true });
         }
         // -------------------------------------------------------------------------
         // Driver event mapping
@@ -5857,6 +5914,28 @@
                 };
                 player.on(dashjs.MediaPlayer.events['STREAM_INITIALIZED'], onInit);
             });
+            // Post-init state reconciliation (same as HLS engine — see comment there)
+            const reconcileVideo = video;
+            const reconcileState = state;
+            let reconcileCount = 0;
+            const reconcileTimer = setInterval(() => {
+                reconcileCount++;
+                if (reconcileCount >= 10) {
+                    clearInterval(reconcileTimer);
+                    return;
+                }
+                const fsm = reconcileState.playbackState;
+                if (fsm !== 'playing' && !reconcileVideo.paused && reconcileVideo.currentTime > 0) {
+                    reconcileState.playbackState = 'playing';
+                    clearInterval(reconcileTimer);
+                    return;
+                }
+                if ((fsm === 'buffering' || fsm === 'loading') && reconcileVideo.paused) {
+                    reconcileState.playbackState = 'paused';
+                    clearInterval(reconcileTimer);
+                }
+            }, 200);
+            signal.addEventListener('abort', () => clearInterval(reconcileTimer), { once: true });
         }
         // -------------------------------------------------------------------------
         // Event mapping
@@ -6113,6 +6192,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 +6507,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);