eb-player 2.0.10 → 2.0.12

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.10";
+    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 });
@@ -5398,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
@@ -5873,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