stormcloud-video-player 0.2.31 → 0.2.32

package/lib/index.cjs

@@ -706,6 +706,15 @@ function createImaController(video, options) {
                         "[IMA] Content video continues in background (Live mode)"
                       );
                     }
+                    hideContentVideo();
+                    if (adContainerEl) {
+                      adContainerEl.style.pointerEvents = "auto";
+                      adContainerEl.style.display = "flex";
+                      adContainerEl.style.backgroundColor = "#000";
+                      adContainerEl.offsetHeight;
+                      adContainerEl.style.opacity = "1";
+                      console.log("[IMA] Ad container shown on content pause");
+                    }
                     adPlaying = true;
                     setAdPlayingFlag(true);
                     emit("content_pause");
@@ -2240,6 +2249,9 @@ var StormcloudVideoPlayer = class {
     this.hasInitialBufferCompleted = false;
     this.adPodAllUrls = [];
     this.preloadingAdUrls = /* @__PURE__ */ new Set();
+    this.vastToMediaUrlMap = /* @__PURE__ */ new Map();
+    this.preloadedMediaUrls = /* @__PURE__ */ new Set();
+    this.preloadingMediaUrls = /* @__PURE__ */ new Set();
     initializePolyfills();
     const browserOverrides = getBrowserConfigOverrides();
     this.config = { ...config, ...browserOverrides };
@@ -2512,27 +2524,44 @@ var StormcloudVideoPlayer = class {
     });
     this.ima.on("ad_error", () => {
       if (this.config.debugAdTiming) {
-        console.log("[StormcloudVideoPlayer] IMA ad_error event received");
+        console.log("[StormcloudVideoPlayer] IMA ad_error event received", {
+          showAds: this.showAds,
+          inAdBreak: this.inAdBreak,
+          remainingAds: this.adPodQueue.length
+        });
       }
-      if (this.showAds) {
-        if (this.inAdBreak) {
-          const remaining = this.getRemainingAdMs();
-          if (remaining > 500 && this.adPodQueue.length > 0) {
-            const next = this.adPodQueue.shift();
+      if (this.inAdBreak) {
+        const remaining = this.getRemainingAdMs();
+        if (remaining > 500 && this.adPodQueue.length > 0) {
+          const nextPreloaded = this.findNextPreloadedAd();
+          if (nextPreloaded) {
             this.currentAdIndex++;
-            this.playSingleAd(next).catch(() => {
+            if (this.config.debugAdTiming) {
+              console.log(
+                `[StormcloudVideoPlayer] Skipping to next preloaded ad after error`
+              );
+            }
+            this.playSingleAd(nextPreloaded).catch(() => {
+              this.handleAdFailure();
             });
           } else {
+            if (this.config.debugAdTiming) {
+              console.log(
+                "[StormcloudVideoPlayer] No preloaded ads available, ending ad break"
+              );
+            }
             this.handleAdFailure();
           }
         } else {
-          if (this.config.debugAdTiming) {
-            console.log(
-              "[StormcloudVideoPlayer] Ad error before ad break established - cleaning up"
-            );
-          }
           this.handleAdFailure();
         }
+      } else {
+        if (this.config.debugAdTiming) {
+          console.log(
+            "[StormcloudVideoPlayer] Ad error before ad break established - cleaning up"
+          );
+        }
+        this.handleAdFailure();
       }
     });
     this.ima.on("content_pause", () => {
@@ -2563,22 +2592,31 @@ var StormcloudVideoPlayer = class {
       }
       const remaining = this.getRemainingAdMs();
       if (remaining > 500 && this.adPodQueue.length > 0) {
-        const next = this.adPodQueue.shift();
-        this.currentAdIndex++;
-        this.enforceAdHoldState();
-        if (this.config.debugAdTiming) {
-          console.log(
-            `[StormcloudVideoPlayer] Playing next ad in pod (${this.currentAdIndex}/${this.totalAdsInBreak}) - IMMEDIATELY starting next ad`
-          );
-        }
-        this.playSingleAd(next).catch(() => {
+        const nextPreloaded = this.findNextPreloadedAd();
+        if (nextPreloaded) {
+          this.currentAdIndex++;
+          this.enforceAdHoldState();
           if (this.config.debugAdTiming) {
-            console.error(
-              "[StormcloudVideoPlayer] Failed to play next ad in pod"
+            console.log(
+              `[StormcloudVideoPlayer] Playing next preloaded ad in pod (${this.currentAdIndex}/${this.totalAdsInBreak})`
+            );
+          }
+          this.playSingleAd(nextPreloaded).catch(() => {
+            if (this.config.debugAdTiming) {
+              console.error(
+                "[StormcloudVideoPlayer] Failed to play next ad in pod"
+              );
+            }
+            this.handleAdPodComplete();
+          });
+        } else {
+          if (this.config.debugAdTiming) {
+            console.log(
+              "[StormcloudVideoPlayer] No preloaded ads available - completing ad break"
             );
           }
           this.handleAdPodComplete();
-        });
+        }
       } else {
         if (this.config.debugAdTiming) {
           console.log(
@@ -2823,6 +2861,9 @@ var StormcloudVideoPlayer = class {
           const first = tags[0];
           const rest = tags.slice(1);
           this.adPodQueue = rest;
+          if (!this.showAds) {
+            this.ima.updateOriginalMutedState(this.video.muted, this.video.volume);
+          }
           this.playSingleAd(first).catch(() => {
           });
         }
@@ -3179,19 +3220,38 @@ var StormcloudVideoPlayer = class {
     if (vastTagUrls.length > 0) {
       this.adPodAllUrls = [...vastTagUrls];
       this.preloadingAdUrls.clear();
+      this.vastToMediaUrlMap.clear();
+      this.preloadedMediaUrls.clear();
+      this.preloadingMediaUrls.clear();
       this.logQueuedAdUrls(this.adPodAllUrls);
+      if (this.config.debugAdTiming) {
+        console.log(
+          `[StormcloudVideoPlayer] Capturing original audio state before ad break:`,
+          {
+            videoMuted: this.video.muted,
+            videoVolume: this.video.volume
+          }
+        );
+      }
+      this.ima.updateOriginalMutedState(this.video.muted, this.video.volume);
       this.inAdBreak = true;
-      this.showAds = true;
       this.currentAdIndex = 0;
       this.totalAdsInBreak = vastTagUrls.length;
       this.adPodQueue = [...vastTagUrls];
       this.enforceAdHoldState();
-      this.preloadUpcomingAds();
       if (this.config.debugAdTiming) {
         console.log(
-          `[StormcloudVideoPlayer] Starting ad pod with ${vastTagUrls.length} ads - will play continuously`
+          `[StormcloudVideoPlayer] Starting ad pod with ${vastTagUrls.length} ads - preloading all ads in parallel`
         );
       }
+      this.preloadAllAdsInBackground().catch((error) => {
+        if (this.config.debugAdTiming) {
+          console.warn(
+            "[StormcloudVideoPlayer] Error in background preloading:",
+            error
+          );
+        }
+      });
       try {
         await this.playAdPod();
       } catch (error) {
@@ -3217,14 +3277,28 @@ var StormcloudVideoPlayer = class {
       }
       return;
     }
-    const firstAd = this.adPodQueue.shift();
+    await new Promise((resolve) => setTimeout(resolve, 500));
+    const firstPreloaded = this.findNextPreloadedAd();
+    if (!firstPreloaded) {
+      if (this.config.debugAdTiming) {
+        console.log(
+          "[StormcloudVideoPlayer] No preloaded ads available after waiting, trying first ad anyway"
+        );
+      }
+      const firstAd = this.adPodQueue.shift();
+      if (firstAd) {
+        this.currentAdIndex++;
+        await this.playSingleAd(firstAd);
+      }
+      return;
+    }
     this.currentAdIndex++;
     if (this.config.debugAdTiming) {
       console.log(
-        `[StormcloudVideoPlayer] Playing ad ${this.currentAdIndex}/${this.totalAdsInBreak}`
+        `[StormcloudVideoPlayer] Playing first preloaded ad ${this.currentAdIndex}/${this.totalAdsInBreak}`
       );
     }
-    await this.playSingleAd(firstAd);
+    await this.playSingleAd(firstPreloaded);
   }
   findCurrentOrNextBreak(nowMs) {
     var _a;
@@ -3257,6 +3331,7 @@ var StormcloudVideoPlayer = class {
         const first = tags[0];
         const rest = tags.slice(1);
         this.adPodQueue = rest;
+        this.ima.updateOriginalMutedState(this.video.muted, this.video.volume);
         this.enforceAdHoldState();
         await this.playSingleAd(first);
         this.inAdBreak = true;
@@ -3377,27 +3452,9 @@ var StormcloudVideoPlayer = class {
         `[StormcloudVideoPlayer] IMA SDK preloaded this ad already: ${vastTagUrl}`
       );
     }
-    if (!this.showAds) {
-      if (this.config.debugAdTiming) {
-        console.log(
-          `[StormcloudVideoPlayer] Capturing original state before ad request:`,
-          {
-            videoMuted: this.video.muted,
-            videoVolume: this.video.volume,
-            showAds: this.showAds
-          }
-        );
-      }
-      this.ima.updateOriginalMutedState(this.video.muted, this.video.volume);
-    } else if (this.config.debugAdTiming) {
-      console.log(
-        `[StormcloudVideoPlayer] Keeping existing original mute state (currently showing ads)`
-      );
-    }
     this.startAdFailsafeTimer();
     try {
       await this.ima.requestAds(vastTagUrl);
-      this.preloadUpcomingAds();
       try {
         if (this.config.debugAdTiming) {
           console.log(
@@ -3406,9 +3463,10 @@ var StormcloudVideoPlayer = class {
         }
         this.enforceAdHoldState();
         await this.ima.play();
+        this.showAds = true;
         if (this.config.debugAdTiming) {
           console.log(
-            "[StormcloudVideoPlayer] Ad playback started successfully"
+            "[StormcloudVideoPlayer] Ad playback started successfully, showAds = true"
           );
         }
       } catch (playError) {
@@ -3436,6 +3494,9 @@ var StormcloudVideoPlayer = class {
     }
     this.releaseAdHoldState();
     this.preloadingAdUrls.clear();
+    this.vastToMediaUrlMap.clear();
+    this.preloadedMediaUrls.clear();
+    this.preloadingMediaUrls.clear();
     this.inAdBreak = false;
     this.expectedAdBreakDurationMs = void 0;
     this.currentAdBreakStartWallClockMs = void 0;
@@ -3545,44 +3606,204 @@ var StormcloudVideoPlayer = class {
       this.ima.hidePlaceholder();
     }
   }
-  preloadUpcomingAds() {
-    if (!this.ima.preloadAds || this.adPodQueue.length === 0) {
-      return;
+  async fetchAndParseVastXml(vastTagUrl) {
+    try {
+      const response = await fetch(vastTagUrl, { mode: "cors" });
+      if (!response.ok) {
+        throw new Error(`Failed to fetch VAST: ${response.status}`);
+      }
+      const xmlText = await response.text();
+      return this.extractMediaUrlsFromVast(xmlText);
+    } catch (error) {
+      if (this.config.debugAdTiming) {
+        console.warn(
+          `[StormcloudVideoPlayer] Failed to fetch/parse VAST XML: ${vastTagUrl}`,
+          error
+        );
+      }
+      return [];
     }
-    const upcoming = this.adPodQueue.slice(0, 2);
-    for (const url of upcoming) {
-      if (!url) continue;
-      if (this.ima.hasPreloadedAd(url)) {
-        this.preloadingAdUrls.delete(url);
-        continue;
+  }
+  extractMediaUrlsFromVast(xmlText) {
+    var _a;
+    const mediaUrls = [];
+    try {
+      const parser = new DOMParser();
+      const xmlDoc = parser.parseFromString(xmlText, "text/xml");
+      const mediaFileElements = xmlDoc.querySelectorAll("MediaFile");
+      for (const mediaFile of Array.from(mediaFileElements)) {
+        const url = (_a = mediaFile.textContent) == null ? void 0 : _a.trim();
+        if (url) {
+          const lowerUrl = url.toLowerCase();
+          if (lowerUrl.endsWith(".mp4") || lowerUrl.endsWith(".webm") || lowerUrl.endsWith(".mov") || lowerUrl.endsWith(".avi") || lowerUrl.includes(".mp4?") || lowerUrl.includes(".webm?") || lowerUrl.includes("/mp4/") || lowerUrl.includes("type=video")) {
+            mediaUrls.push(url);
+          }
+        }
       }
-      if (this.preloadingAdUrls.has(url)) {
-        continue;
+      if (this.config.debugAdTiming && mediaUrls.length > 0) {
+        console.log(
+          `[StormcloudVideoPlayer] Extracted ${mediaUrls.length} media URLs from VAST:`,
+          mediaUrls
+        );
+      }
+    } catch (error) {
+      if (this.config.debugAdTiming) {
+        console.warn(
+          "[StormcloudVideoPlayer] Failed to parse VAST XML:",
+          error
+        );
       }
+    }
+    return mediaUrls;
+  }
+  async preloadMediaFile(mediaUrl) {
+    if (this.preloadedMediaUrls.has(mediaUrl)) {
+      return;
+    }
+    if (this.preloadingMediaUrls.has(mediaUrl)) {
+      return;
+    }
+    this.preloadingMediaUrls.add(mediaUrl);
+    try {
       if (this.config.debugAdTiming) {
         console.log(
-          `[StormcloudVideoPlayer] Scheduling IMA preload for upcoming ad: ${url}`
+          `[StormcloudVideoPlayer] Preloading video file: ${mediaUrl}`
         );
       }
-      this.preloadingAdUrls.add(url);
-      this.ima.preloadAds(url).then(() => {
+      const response = await fetch(mediaUrl, {
+        mode: "cors",
+        method: "GET",
+        headers: {
+          Range: "bytes=0-1048576"
+        }
+      });
+      if (response.ok || response.status === 206) {
+        this.preloadedMediaUrls.add(mediaUrl);
         if (this.config.debugAdTiming) {
           console.log(
-            `[StormcloudVideoPlayer] IMA preload complete for ad: ${url}`
+            `[StormcloudVideoPlayer] Successfully preloaded video file: ${mediaUrl}`
           );
         }
-      }).catch((error) => {
+      }
+    } catch (error) {
+      if (this.config.debugAdTiming) {
+        console.warn(
+          `[StormcloudVideoPlayer] Failed to preload video file: ${mediaUrl}`,
+          error
+        );
+      }
+    } finally {
+      this.preloadingMediaUrls.delete(mediaUrl);
+    }
+  }
+  async preloadAllAdsInBackground() {
+    if (this.adPodAllUrls.length === 0) {
+      return;
+    }
+    if (this.config.debugAdTiming) {
+      console.log(
+        `[StormcloudVideoPlayer] Starting parallel preload of ${this.adPodAllUrls.length} ads`
+      );
+    }
+    const preloadPromises = this.adPodAllUrls.map(
+      (vastTagUrl) => this.preloadSingleAd(vastTagUrl).catch((error) => {
         if (this.config.debugAdTiming) {
           console.warn(
-            `[StormcloudVideoPlayer] IMA preload failed for ad: ${url}`,
+            `[StormcloudVideoPlayer] Preload failed for ${vastTagUrl}:`,
             error
           );
         }
-      }).finally(() => {
-        this.preloadingAdUrls.delete(url);
-      });
+      })
+    );
+    await Promise.all(preloadPromises);
+    if (this.config.debugAdTiming) {
+      console.log(
+        `[StormcloudVideoPlayer] Background preloading completed for all ads`
+      );
     }
   }
+  async preloadSingleAd(vastTagUrl) {
+    if (!vastTagUrl) return;
+    try {
+      if (this.ima.preloadAds && !this.ima.hasPreloadedAd(vastTagUrl)) {
+        if (!this.preloadingAdUrls.has(vastTagUrl)) {
+          if (this.config.debugAdTiming) {
+            console.log(
+              `[StormcloudVideoPlayer] Preloading VAST: ${vastTagUrl}`
+            );
+          }
+          this.preloadingAdUrls.add(vastTagUrl);
+          await this.ima.preloadAds(vastTagUrl).then(() => {
+            if (this.config.debugAdTiming) {
+              console.log(
+                `[StormcloudVideoPlayer] IMA VAST preload complete: ${vastTagUrl}`
+              );
+            }
+          }).catch((error) => {
+            if (this.config.debugAdTiming) {
+              console.warn(
+                `[StormcloudVideoPlayer] IMA VAST preload failed: ${vastTagUrl}`,
+                error
+              );
+            }
+          }).finally(() => {
+            this.preloadingAdUrls.delete(vastTagUrl);
+          });
+        }
+      }
+      let mediaUrls = this.vastToMediaUrlMap.get(vastTagUrl);
+      if (!mediaUrls) {
+        if (this.config.debugAdTiming) {
+          console.log(
+            `[StormcloudVideoPlayer] Fetching and parsing VAST to extract media URLs: ${vastTagUrl}`
+          );
+        }
+        mediaUrls = await this.fetchAndParseVastXml(vastTagUrl);
+        if (mediaUrls.length > 0) {
+          this.vastToMediaUrlMap.set(vastTagUrl, mediaUrls);
+        }
+      }
+      if (mediaUrls && mediaUrls.length > 0) {
+        const primaryMediaUrl = mediaUrls[0];
+        if (primaryMediaUrl && !this.preloadedMediaUrls.has(primaryMediaUrl)) {
+          await this.preloadMediaFile(primaryMediaUrl);
+        }
+      }
+    } catch (error) {
+      if (this.config.debugAdTiming) {
+        console.warn(
+          `[StormcloudVideoPlayer] Failed to preload ad: ${vastTagUrl}`,
+          error
+        );
+      }
+    }
+  }
+  findNextPreloadedAd() {
+    var _a, _b, _c;
+    for (let i = 0; i < this.adPodQueue.length; i++) {
+      const vastTagUrl = this.adPodQueue[i];
+      if (!vastTagUrl) continue;
+      const hasImaPreload = (_c = (_b = (_a = this.ima).hasPreloadedAd) == null ? void 0 : _b.call(_a, vastTagUrl)) != null ? _c : false;
+      const mediaUrls = this.vastToMediaUrlMap.get(vastTagUrl);
+      const hasMediaPreload = mediaUrls && mediaUrls.length > 0 ? this.preloadedMediaUrls.has(mediaUrls[0]) : false;
+      if (hasImaPreload || hasMediaPreload) {
+        if (this.config.debugAdTiming) {
+          console.log(
+            `[StormcloudVideoPlayer] Found preloaded ad at index ${i}: ${vastTagUrl}`,
+            { hasImaPreload, hasMediaPreload }
+          );
+        }
+        this.adPodQueue.splice(0, i + 1);
+        return vastTagUrl;
+      }
+    }
+    if (this.config.debugAdTiming) {
+      console.log(
+        "[StormcloudVideoPlayer] No preloaded ads found in queue"
+      );
+    }
+    return void 0;
+  }
   getRemainingAdMs() {
     if (this.expectedAdBreakDurationMs == null || this.currentAdBreakStartWallClockMs == null)
       return 0;
@@ -3751,6 +3972,9 @@ var StormcloudVideoPlayer = class {
     (_b = this.ima) == null ? void 0 : _b.destroy();
     this.releaseAdHoldState();
     this.preloadingAdUrls.clear();
+    this.vastToMediaUrlMap.clear();
+    this.preloadedMediaUrls.clear();
+    this.preloadingMediaUrls.clear();
     this.adPodAllUrls = [];
   }
 };