eb-player 2.1.3 → 2.1.4

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.1.3";
+    var __EB_PLAYER_VERSION__ = "2.1.4";
 
     /**
      * Finite State Machine for player playback state transitions.
@@ -4397,8 +4397,9 @@
      * Mount order:
      *   1. CSS vars / data-theme applied to container
      *   2. Config-derived state (isRtl, isRadio) set
-     *   3. SkinRoot connected (needs DOM) — creates video element and ads container
-     *   4. AutoHideController + KeyboardController wired
+     *   3. SkinRoot connected (needs DOM) — creates the video element on every
+     *      mount, including noUi; the ads container is only rendered in UI mode
+     *   4. AutoHideController + KeyboardController wired (UI mode only)
      *   5. Integrations initialized (need skin DOM for ads)
      *
      * Dispose order (reverse of mount):
@@ -4483,21 +4484,32 @@
             // Set config-derived state flags
             this.state.isRtl = this.config.lang === 'ar';
             this.state.isRadio = this.config.radio === true;
-            // Step 3: Create SkinRoot (unless noUi mode)
+            // Step 3: Create SkinRoot. This runs on EVERY mount, including noUi —
+            // SkinRoot is the only creator of the <video> element, and its own
+            // template() already branches to a headless template that renders just
+            // the bare element (see renderNoUiTemplate() in skin-root.ts). This block
+            // used to be gated on `!this.config.noUi`, which left that headless
+            // branch unreachable from the real player: a noUi mount produced an
+            // empty container, no <video> was ever handed to the engine, and
+            // therefore start() issued no CDN token, no manifest and no segment
+            // request at all.
+            const skinRoot = new SkinRoot();
+            this.skinRoot = skinRoot;
+            skinRoot.connect(container, this.state, this.bus, this.config, this.i18n);
+            // Sync initial muted/volume from the actual video element so UI matches
+            // reality. The volumechange event only fires on *changes*, not on initial
+            // attribute values set during element creation. The browser is the source
+            // of truth — it may override the muted attribute based on autoplay policy.
+            const videoEl = skinRoot.getVideoElement();
+            if (videoEl !== null) {
+                this.state.muted = videoEl.muted;
+                this.state.volume = videoEl.volume;
+            }
+            // Step 4: Wire activity and keyboard controllers — chrome-only, so they
+            // stay gated on noUi (D-03). AutoHide drives visibility for controls that
+            // don't exist headlessly; Keyboard would claim page-level key handling
+            // that a headless integrator expects to own itself.
             if (!this.config.noUi) {
-                const skinRoot = new SkinRoot();
-                this.skinRoot = skinRoot;
-                skinRoot.connect(container, this.state, this.bus, this.config, this.i18n);
-                // Sync initial muted/volume from the actual video element so UI matches
-                // reality. The volumechange event only fires on *changes*, not on initial
-                // attribute values set during element creation. The browser is the source
-                // of truth — it may override the muted attribute based on autoplay policy.
-                const videoEl = skinRoot.getVideoElement();
-                if (videoEl !== null) {
-                    this.state.muted = videoEl.muted;
-                    this.state.volume = videoEl.volume;
-                }
-                // Step 4: Wire activity and keyboard controllers
                 new AutoHideController(container, this.state, this.signal);
                 new KeyboardController(container, this.state, this.bus, this.config, this.signal);
             }
@@ -4592,12 +4604,16 @@
                 const playlistManager = new PlaylistManager();
                 playlistManager.init(config, state, bus, signal);
             }
-            // AdsManager: skip when config.ad is undefined (D-09)
+            // AdsManager: skip when config.ad is undefined (D-09), or when no ads
+            // container exists — the headless template (D-04) renders none, so a
+            // noUi mount must not construct AdsManager at all, not merely skip
+            // init(). Constructing it unconditionally on skinRoot !== null would
+            // regress now that SkinRoot is created in noUi mode too (D-01).
             if (config.ad && this.skinRoot !== null) {
-                const adsManager = new AdsManager();
                 const video = this.skinRoot.getVideoElement();
                 const adsContainer = this.skinRoot.getAdsContainer();
                 if (video !== null && adsContainer !== null) {
+                    const adsManager = new AdsManager();
                     adsManager.init(config, state, bus, video, adsContainer, signal).catch((error) => {
                         console.error('EBPlayer: AdsManager init failed:', error);
                     });
@@ -7531,10 +7547,11 @@
      * (20s) so that more precise, better-logged inner mechanism wins first in a
      * live player — this is the outer safety net, not the primary signal. Covers
      * two cases the inner mechanism cannot: an AdsManager that was never
-     * constructed at all (noUi:true, or a null ads container — lifecycle.ts
-     * skips the branch that would create one), and an AdsManager that obtained
-     * its manager from the loader (disarming its own bound) whose creative then
-     * never reached the screen.
+     * constructed at all (a headless player renders no ads container, so the
+     * ads branch in lifecycle.ts is still skipped for that reason (D-04) — this
+     * backstop applies unchanged to noUi + ad configurations), and an AdsManager
+     * that obtained its manager from the loader (disarming its own bound) whose
+     * creative then never reached the screen.
      */
     const MAIN_OPEN_FALLBACK_MS = 30000;
     // ---------------------------------------------------------------------------
@@ -7569,7 +7586,13 @@
         // so the config-level swap is legitimate for that field only). NEVER mutate
         // `mergedConfig.muted` — it is consumed only at video element creation in
         // skin-root.ts:141/318 and is a no-op for runtime mute.
-        const originalMuted = mergedConfig.muted ?? false;
+        //
+        // `mergedConfig.muted` is typed `boolean` (required, non-optional) on
+        // PlayerConfig, and DEFAULT_CONFIG.muted is the boolean literal `true` —
+        // mergeConfig()'s deepMerge always falls back to the base value for an
+        // undefined override (see config.ts), so this field can never be nullish
+        // through the real merge. No `?? false` fallback needed.
+        const originalMuted = mergedConfig.muted;
         const originalManager = mergedConfig.manager;
         const originalStartAt = mergedConfig.startAt;
         const controller = new PlayerController(runtimeConfig);
@@ -7748,6 +7771,21 @@
         controller.bus.on('error-fatal', () => {
             inst.p2p?.stop();
         }, { signal: controller.signal });
+        // Fail loud when mount() produced no video element (D-06). Without one,
+        // engine.setVideo() is skipped inside open() (see the `video !== null`
+        // guard above), so no engine ever attaches media and nothing is requested
+        // at all — no CDN token, no manifest, no segments. No watchdog covers
+        // this: the load-never-started watchdog lives inside the engine and is
+        // only armed once a driver exists. state.error (not a bus emit) is the
+        // channel here because start() has not returned the reference yet, so no
+        // consumer can have subscribed to the bus at this point, whereas the
+        // reactive state store is readable at any time afterwards.
+        if (video === null) {
+            const message = 'EBPlayer: no <video> element found in the container after mount() — playback cannot start.';
+            console.error(message);
+            controller.state.error = message;
+            return reference;
+        }
         // Phase 7/8 — pre-main leg orchestration.
         // When mergedConfig.preroll is set, open the intro stream first, then on
         // bus 'intro-stream-complete' (emitted by IntroStreamManager on video.ended,
@@ -7784,9 +7822,11 @@
             // same tick. complete() is idempotent, so on the normal ordering (intro
             // already finished) this is a no-op; the listener is already torn down.
             controller.bus.emit('force-intro-complete');
-            if (video !== null) {
-                video.muted = originalMuted;
-            }
+            // D-06: `video` is guaranteed non-null here — the guard above (line ~415)
+            // already returned early when mount() produced no <video>, and `video`
+            // is a `const`, so TypeScript's control-flow narrowing carries the
+            // non-null guarantee into this closure without a redundant re-check.
+            video.muted = originalMuted;
             controller.state.muted = originalMuted;
             // CR-05: keep mergedConfig.manager and controller.config.manager in sync.
             // start() builds mergedConfig and PlayerController builds its own merged
@@ -7871,7 +7911,9 @@
                 return;
             deferredPlaybackStarted = true;
             const engine = inst.engine;
-            if (engine === null || video === null)
+            // D-06: `video === null` is unreachable here — see the comment on the
+            // equivalent guard in openMainStream() above.
+            if (engine === null)
                 return;
             // Honor the user's click intent. CommandHandler's earlier bus.on('play')
             // listener fired before us with no source attached, so its video.play()
@@ -7941,9 +7983,9 @@
             }, { signal: controller.signal });
             // Force runtime mute off for the intro pass — applied to the LIVE <video>
             // element and PlayerState, NOT to mergedConfig.muted (no-op for runtime).
-            if (video !== null) {
-                video.muted = false;
-            }
+            // D-06: `video` is guaranteed non-null here — see the comment on the
+            // equivalent restore in openMainStream() above.
+            video.muted = false;
             controller.state.muted = false;
             // Skip P2P attach for the intro stream (D-08); restored before main open.
             // CR-05: keep the dual-merged configs in sync (see openMainStream).