@amazon/vinyl 4.0.0 → 4.0.1-next.20261016184530

package/dist/unit/types/current/vinyl/VinylPlayerAdBreaks.test.js

@@ -15,11 +15,14 @@ describe('VinylPlayer ad break API', () => {
     beforeEach(() => {
         base = createMockVinylDependencies();
         // Use a real ad controller so setTrackAds drives state and events that the
-        // player getters and redispatch reflect.
-        adController = new AdControllerImpl({
-            playbackController: base.playbackController,
-        });
-        depFactories = externalDependencies({ ...base, adController });
+        // player getters and redispatch reflect. The player owns it, so disposing
+        // the player cancels the load timeout an entered ad arms.
+        depFactories = {
+            ...externalDependencies(base),
+            adController: () => (adController = new AdControllerImpl({
+                playbackController: base.playbackController,
+            })),
+        };
         player = createVinylPlayer({ media: new MockHTMLAudioElement() }, depFactories);
     });
     afterEach(() => {

package/dist/vinylTestUtil/index.js

@@ -1653,9 +1653,10 @@ import { createLogPrefix } from "@amazon/vinyl-util";
 
 // test/vinylTestUtil/player/mediaRef.ts
 import { lazy } from "@amazon/vinyl-util";
+var MEDIA_VOLUME = 1e-4;
 var mediaRef = lazy(() => {
   const media = document.createElement("video");
-  media.muted = true;
+  media.volume = MEDIA_VOLUME;
   media.playsInline = true;
   media.disableRemotePlayback = true;
   return media;
@@ -1668,39 +1669,7 @@ afterEach(() => {
   }
 });
 
-// test/vinylTestUtil/ui/requireUserInteraction.ts
-async function requireUserInteraction() {
-  const audioPrompt = document.getElementById("unlockAudioPrompt");
-  audioPrompt.style.removeProperty("display");
-  const body = document.body;
-  body.focus();
-  await new Promise((resolve) => {
-    const done = () => {
-      body.removeEventListener("click", done);
-      body.removeEventListener("keypress", done);
-      body.removeEventListener("touchend", done);
-      return resolve(void 0);
-    };
-    body.addEventListener("click", done);
-    body.addEventListener("keypress", done);
-    body.addEventListener("touchend", done);
-  });
-  audioPrompt.style.display = "none";
-}
-
-// test/vinylTestUtil/media/unlockMediaElement.ts
-import { noop } from "@amazon/vinyl-util";
-async function unlockMediaElement() {
-  const media = mediaRef.value;
-  media.src = vinylTestAssets.prog.libmp3lame_60s_2ch_16bit_44100Hz_48kbps;
-  await media.play().catch(noop);
-  media.pause();
-  media.removeAttribute("src");
-  media.load();
-}
-
 // test/vinylTestUtil/media/FrequencyAnalyzer.ts
-import { setNextTestTimeout } from "@amazon/vinyl-util/browserTestUtil";
 var TIME_ESTIMATE_TOLERANCE = 0.02;
 var defaultFrequencyAnalyzerOptions = {
   startFrequency: 100,
@@ -1798,6 +1767,7 @@ var FrequencyAnalyzer = class {
     }
   }
 };
+var ANALYZER_VOLUME = 0.01;
 var _a;
 var shouldCheckAudio = parseBoolean(
   ((_a = getSearchParams().get("checkAudio")) != null ? _a : "0").toLowerCase()
@@ -1808,26 +1778,80 @@ function assertFrequency() {
   return (_a2 = frequencyAnalyzer == null ? void 0 : frequencyAnalyzer.assertFrequency()) != null ? _a2 : Promise.resolve();
 }
 function initializeFrequencyAnalyzer() {
-  if (shouldCheckAudio) {
-    setNextTestTimeout(300);
-    beforeAll(async () => {
-      const media = mediaRef.value;
-      media.crossOrigin = "anonymous";
-      media.muted = false;
-      media.volume = 0.01;
-      await requireUserInteraction();
-      const audioContext = getAudioContext();
-      await unlockMediaElement();
-      if (audioContext) {
-        const source = audioContext.createMediaElementSource(
-          mediaRef.value
+  if (!shouldCheckAudio) return;
+  beforeAll(() => {
+    const media = mediaRef.value;
+    media.crossOrigin = "anonymous";
+    media.volume = ANALYZER_VOLUME;
+    const audioContext = getAudioContext();
+    if (audioContext) {
+      const source = audioContext.createMediaElementSource(media);
+      frequencyAnalyzer = new FrequencyAnalyzer(audioContext, source);
+    } else {
+      console.warn("AudioContext not supported");
+    }
+  });
+}
+
+// test/vinylTestUtil/media/unlockMediaElement.ts
+import { getAudioContext as getAudioContext2 } from "@amazon/vinyl";
+
+// test/vinylTestUtil/ui/requireUserInteraction.ts
+async function requireUserInteraction(onInteraction) {
+  var _a2;
+  const prompt = document.getElementById("unlockAudioPrompt");
+  prompt.style.removeProperty("display");
+  (_a2 = prompt.querySelector("button")) == null ? void 0 : _a2.focus();
+  await new Promise((resolve) => {
+    let handling = false;
+    const handler = (event) => {
+      var _a3;
+      if (handling) return;
+      handling = true;
+      const result = (_a3 = onInteraction == null ? void 0 : onInteraction()) != null ? _a3 : Promise.resolve();
+      result.then(() => {
+        prompt.removeEventListener("click", handler);
+        document.removeEventListener("keydown", handler);
+        resolve();
+      }).catch((error) => {
+        console.warn(
+          `The ${event.type} (isTrusted: ${event.isTrusted}) was not accepted as a user gesture; interact again.`,
+          error
         );
-        frequencyAnalyzer = new FrequencyAnalyzer(audioContext, source);
-      } else {
-        console.warn("AudioContext not supported");
-      }
-    });
+      }).finally(() => {
+        handling = false;
+      });
+    };
+    prompt.addEventListener("click", handler);
+    document.addEventListener("keydown", handler);
+  });
+  prompt.style.display = "none";
+}
+
+// test/vinylTestUtil/media/unlockMediaElement.ts
+import { noop } from "@amazon/vinyl-util";
+var MAX_TIMEOUT_MS = 2147483647;
+async function unlockMediaElement() {
+  var _a2;
+  const media = mediaRef.value;
+  media.src = vinylTestAssets.prog.libmp3lame_60s_2ch_16bit_44100Hz_48kbps;
+  const played = media.play();
+  const resumed = (_a2 = getAudioContext2()) == null ? void 0 : _a2.resume().catch(noop);
+  try {
+    await played;
+  } finally {
+    media.pause();
+    media.removeAttribute("src");
+    media.load();
   }
+  await resumed;
+}
+function initializeMediaUnlock() {
+  if (typeof document === "undefined") return;
+  beforeAll(async () => {
+    await requireUserInteraction(unlockMediaElement);
+    console.info("Media element unlocked");
+  }, MAX_TIMEOUT_MS);
 }
 
 // test/vinylTestUtil/mediaSource/ControlledMediaSource.ts
@@ -2863,6 +2887,7 @@ var VinylSuite = class {
         this.visibilityChangeHandler
       );
       this._player = this.playerFactory();
+      this._player.volume = shouldCheckAudio ? ANALYZER_VOLUME : MEDIA_VOLUME;
       add(
         this._player.on("error", (e) => {
           logError(this, "player emitted error event", toJson(e));
@@ -3041,13 +3066,13 @@ import { sleep as sleep3 } from "@amazon/vinyl-util";
 var sleepInterval = 1;
 var affordanceBefore = 1;
 var affordanceAfter = 3;
-async function expectTrackPlaysUntil(player, endTime, timeout = 20) {
+async function expectTrackPlaysUntil(player, endTime, timeout = 20, { timeoutScale = 1 } = {}) {
   await onPlaying(player);
   await onTimeUpdate(player);
   const startedBeforeEnd = player.currentTime < endTime;
   await assertFrequency();
   let elapsed = 0;
-  const maxTime = endTime - player.currentTime + timeout;
+  const maxTime = (endTime - player.currentTime + timeout) * timeoutScale;
   while (!player.ended && player.currentTime < endTime && elapsed < maxTime) {
     await sleep3(sleepInterval);
     elapsed += sleepInterval;
@@ -3060,7 +3085,7 @@ async function expectTrackPlaysUntil(player, endTime, timeout = 20) {
 
 // test/vinylTestUtil/util/playback/expectTrackPlays.ts
 var PLAYBACK_DURATION = 6;
-async function expectTrackPlays(player) {
+async function expectTrackPlays(player, { timeoutScale = 1 } = {}) {
   const { dispose, add } = createDisposer3();
   const ended = add(createEventSpy2(player, "ended"));
   const timeUpdate = add(createEventSpy2(player, "timeUpdate"));
@@ -3071,12 +3096,14 @@ async function expectTrackPlays(player) {
   if (player.duration > PLAYBACK_DURATION) {
     await expectTrackPlaysUntil(
       player,
-      player.currentTime + PLAYBACK_DURATION / 2
+      player.currentTime + PLAYBACK_DURATION / 2,
+      void 0,
+      { timeoutScale }
     );
     const time = player.duration - PLAYBACK_DURATION / 2;
     await player.seekTo(time);
   }
-  await ended.next(PLAYBACK_DURATION + 10);
+  await ended.next((PLAYBACK_DURATION + 10) * timeoutScale);
   expect(player.currentTime).toBeCloseToWithin(duration, 3);
   expect(player.ended).withContext("ended").toBeTrue();
   expect(timeUpdate.calls.count()).toBeGreaterThanOrEqual(
@@ -3084,10 +3111,10 @@ async function expectTrackPlays(player) {
   );
   dispose();
 }
-async function expectPlaylistPlays(player, playlist) {
+async function expectPlaylistPlays(player, playlist, { timeoutScale = 1 } = {}) {
   var _a2;
   const { dispose, add } = createDisposer3();
-  const trackTimeout = PLAYBACK_DURATION + 60;
+  const trackTimeout = (PLAYBACK_DURATION + 60) * timeoutScale;
   const queueEnded = add(createEventSpy2(player, "queueEnded"));
   const queueChange = add(createEventSpy2(player, "queueChange"));
   const trackChange = add(createEventSpy2(player, "trackActivated"));
@@ -3102,15 +3129,19 @@ async function expectPlaylistPlays(player, playlist) {
     const isLastTrack = i === playlist.length - 1;
     expect((_a2 = player.activeTrack) == null ? void 0 : _a2.uri).withContext("activeTrack uri").toBe(playlist[i].uri);
     const nextTrack = isLastTrack ? queueEnded.next(trackTimeout) : trackChange.next(trackTimeout);
-    await expectTrackPlays(player);
-    await nextTrack;
+    await Promise.all([
+      expectTrackPlays(player, { timeoutScale }),
+      nextTrack
+    ]);
     assertQueueChangeCount(isLastTrack ? 0 : 1);
   }
   dispose();
 }
 export {
+  ANALYZER_VOLUME,
   ControlledMediaSource,
   FrequencyAnalyzer,
+  MEDIA_VOLUME,
   MockAdController,
   MockAutoResetController,
   MockBufferingController,
@@ -3164,6 +3195,7 @@ export {
   expectTrackPlays,
   expectTrackPlaysUntil,
   initializeFrequencyAnalyzer,
+  initializeMediaUnlock,
   mediaRef,
   mockDashManifest,
   mockHlsManifestData,