eb-player 2.0.6 → 2.0.8

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.6";
+    var __EB_PLAYER_VERSION__ = "2.0.7";
 
     /**
      * Finite State Machine for player playback state transitions.
@@ -4284,6 +4284,15 @@
             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.
@@ -5112,6 +5121,14 @@
         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
         // -------------------------------------------------------------------------
@@ -6366,30 +6383,14 @@
                         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();
@@ -6446,9 +6447,22 @@
             }, 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;
     }