@tidal-music/player-web-components 0.1.0

package/dist/browserPlayer-oNOpDVm6-UW0N6pFH.js

@@ -0,0 +1,270 @@
+import { Y as I, O as g, V as p } from "./basePlayer-a-avZASH-Ux-6s9Ex.js";
+import { N as P, A as y, O as E, k as h, y as S, b as L, R as k } from "./index-tM9JvbA8.js";
+class f extends I {
+  #t;
+  #i;
+  #n;
+  #a = !0;
+  #o;
+  #e;
+  #s = !1;
+  name = "browserPlayer";
+  constructor() {
+    super(), this.playbackState = "IDLE";
+    const e = () => {
+      this.mediaElement && !this.mediaElement.paused && (this.playbackState = "PLAYING");
+    }, i = (a) => {
+      this.currentStreamingSessionId && a.target instanceof HTMLMediaElement && h.overwriteDuration(
+        this.currentStreamingSessionId,
+        a.target.duration
+      );
+    }, t = () => {
+      this.playbackState = "STALLED";
+    }, s = () => {
+      (async () => {
+        const a = this.#t;
+        if (a) {
+          if (this.preloadedStreamingSessionId && a.currentTime === a.duration && (await k(1e3), a.currentTime !== a.duration))
+            return;
+          this.playbackState = "NOT_PLAYING";
+        }
+      })().catch(console.error);
+    }, n = (a) => {
+      if (a instanceof Event) {
+        const c = a.target;
+        c.readyState > HTMLMediaElement.HAVE_NOTHING && (this.currentTime = c.currentTime);
+      }
+    }, d = (a) => {
+      n(a), this.finishCurrentMediaProduct("completed");
+    }, r = (a) => console.error("HTMLMediaElement errored", a), l = () => {
+      this.mediaElement && (this.currentTime = this.mediaElement.currentTime, this.seekStart());
+    }, o = () => {
+      this.mediaElement && (this.currentTime = this.mediaElement.currentTime, this.seekEnd());
+    };
+    this.#e = {
+      durationChangeHandler: i,
+      endedHandler: d,
+      errorHandler: r,
+      pauseHandler: s,
+      playHandler: e,
+      playingHandler: e,
+      seekedHandler: o,
+      seekingHandler: l,
+      stalledHandler: t,
+      timeUpdateHandler: n,
+      waitingHandler: t
+    }, P().then().catch(console.error), this.#i = y, this.#n = E, this.currentPlayer = this.#i;
+  }
+  #r() {
+    return [this.#i, this.#n].filter((e) => e !== this.#t).pop();
+  }
+  #d(e, i) {
+    this.debugLog(
+      "mediaElementEvents",
+      i ? "adding to" : "removing from",
+      e
+    );
+    const t = i ? "addEventListener" : "removeEventListener";
+    e[t](
+      "durationchange",
+      this.#e.durationChangeHandler,
+      {
+        passive: !0
+      }
+    ), e[t]("play", this.#e.playHandler, {
+      passive: !0
+    }), e[t](
+      "playing",
+      this.#e.playingHandler,
+      { passive: !0 }
+    ), e[t](
+      "timeupdate",
+      this.#e.timeUpdateHandler,
+      { passive: !0 }
+    ), e[t](
+      "pause",
+      this.#e.pauseHandler,
+      { passive: !0 }
+    ), e[t](
+      "ended",
+      this.#e.endedHandler,
+      { passive: !0 }
+    ), e[t](
+      "error",
+      this.#e.errorHandler,
+      { passive: !0 }
+    ), e[t](
+      "waiting",
+      this.#e.waitingHandler,
+      { passive: !0 }
+    ), e[t](
+      "stalled",
+      this.#e.stalledHandler,
+      { passive: !0 }
+    ), e[t](
+      "seeking",
+      this.#e.seekingHandler,
+      { passive: !0 }
+    ), e[t](
+      "seeked",
+      this.#e.seekedHandler,
+      { passive: !0 }
+    );
+  }
+  getPosition() {
+    return this.debugLog("getPosition"), this.mediaElement && (this.mediaElement.ended ? this.currentTime = 0 : this.currentTime = this.mediaElement.currentTime), this.currentTime;
+  }
+  async load(e, i) {
+    this.debugLog("load", e), this.currentTime = e.assetPosition, this.startAssetPosition = e.assetPosition, await P(), await this.reset(), this.#a = !1, i === "explicit" && (this.playbackState = "NOT_PLAYING");
+    const { assetPosition: t, mediaProduct: s, playbackInfo: n, streamInfo: d } = e;
+    this.currentStreamingSessionId = d.streamingSessionId;
+    const { currentPlayer: r } = this;
+    if (!r)
+      return;
+    const l = new Promise(
+      (u) => r.addEventListener("canplay", () => u(), {
+        once: !0
+      })
+    );
+    r.src = d.streamUrl, r.currentTime = t, r.load();
+    const o = new Promise(
+      (u) => r.addEventListener(
+        "durationchange",
+        (m) => {
+          m.target instanceof HTMLMediaElement && u(m.target.duration);
+        },
+        { once: !0 }
+      )
+    );
+    if (await l, this.currentStreamingSessionId !== d.streamingSessionId)
+      return;
+    const a = await o, c = g({
+      assetPosition: t,
+      duration: a,
+      playbackInfo: n,
+      streamInfo: d
+    });
+    return h.saveMediaProductTransition(
+      d.streamingSessionId,
+      { mediaProduct: s, playbackContext: c }
+    ), this.debugLog("dispatching mediaProductTransition"), S.dispatchEvent(
+      p(s, c)
+    ), this.#s ? (this.#s = !1, this.play()) : Promise.resolve();
+  }
+  async next(e) {
+    this.debugLog("next", e), this.playbackState === "IDLE" && (this.playbackState = "NOT_PLAYING");
+    const { mediaProduct: i, playbackInfo: t, streamInfo: s } = e, n = this.#r();
+    if (this.preloadedStreamingSessionId = s.streamingSessionId, !n)
+      return;
+    n.src = s.streamUrl, n.load();
+    const d = await new Promise(
+      (l) => n.addEventListener(
+        "durationchange",
+        (o) => {
+          o.target instanceof HTMLMediaElement && l(o.target.duration);
+        },
+        { once: !0 }
+      )
+    ), r = g({
+      assetPosition: 0,
+      duration: d,
+      playbackInfo: t,
+      streamInfo: s
+    });
+    h.saveMediaProductTransition(
+      s.streamingSessionId,
+      {
+        mediaProduct: i,
+        playbackContext: r
+      }
+    );
+  }
+  pause() {
+    this.debugLog("pause"), this.mediaElement && this.mediaElement.pause();
+  }
+  async play() {
+    if (this.debugLog("play"), await this.maybeHardReload(), this.playbackState === "IDLE")
+      return this.debugLog("is IDLE, returning early"), this.#s = !0, Promise.resolve();
+    "setSinkId" in y && await this.updateOutputDevice(), this.currentStreamingSessionId && this.mediaProductStarted(this.currentStreamingSessionId), this.setStateToXIfNotYInZMs(1e3, "PLAYING", "STALLED"), this.currentPlayer && await this.currentPlayer.play().catch(console.error);
+  }
+  async playbackEngineEndedHandler(e) {
+    if (this.isActivePlayer) {
+      const { reason: i } = e.detail;
+      i === "completed" && (this.hasNextItem() ? (await this.skipToPreloadedMediaProduct(), await this.play()) : (console.warn("No item preloaded, not progressing."), this.playbackState = "NOT_PLAYING"));
+    }
+  }
+  async reset({ keepPreload: e } = { keepPreload: !1 }) {
+    if (this.#a)
+      return Promise.resolve();
+    this.debugLog("reset"), this.playbackState !== "IDLE" && this.hasStarted() && this.finishCurrentMediaProduct("skip"), this.playbackState = "IDLE", this.detachPlaybackEngineEndedHandler(), this.currentStreamingSessionId = void 0, e || (this.preloadedStreamingSessionId = void 0);
+    const { currentPlayer: i } = this;
+    return i && i.readyState !== 0 && (i.load(), await new Promise(
+      (t) => i.addEventListener("emptied", () => t(), { passive: !0 })
+    )), this.#a = !0, Promise.resolve();
+  }
+  seek(e) {
+    this.debugLog("seek", e);
+    const { currentPlayer: i } = this, t = e;
+    if (i)
+      return "fastSeek" in i ? i.fastSeek(t) : i.currentTime = t, new Promise((s) => {
+        i.addEventListener("seeked", () => s(i.currentTime), {
+          once: !0
+        });
+      });
+  }
+  // eslint-disable-next-line @typescript-eslint/require-await
+  async skipToPreloadedMediaProduct() {
+    const e = h.getMediaProductTransition(
+      this.preloadedStreamingSessionId
+    );
+    if (!e) {
+      this.playbackState = "NOT_PLAYING";
+      return;
+    }
+    this.debugLog(
+      "skipToPreloadedMediaProduct",
+      this.preloadedStreamingSessionId
+    );
+    const i = this.#r();
+    if (i) {
+      this.currentPlayer = i, this.currentStreamingSessionId = String(this.preloadedStreamingSessionId), this.preloadedStreamingSessionId = void 0;
+      const { mediaProduct: t, playbackContext: s } = e;
+      S.dispatchEvent(
+        p(t, s)
+      ), this.playbackState === "IDLE" && (this.playbackState = "NOT_PLAYING");
+    }
+  }
+  togglePlayback() {
+    this.debugLog("togglePlayback"), this.mediaElement && (this.mediaElement.paused ? this.mediaElement.play().catch(console.error) : this.mediaElement.pause());
+  }
+  // eslint-disable-next-line @typescript-eslint/require-await
+  async unloadPreloadedMediaProduct() {
+    this.debugLog(
+      "unloadPreloadedMediaProduct",
+      this.preloadedStreamingSessionId
+    ), this.cleanUpStoredPreloadInfo();
+    const e = this.#r();
+    e && (e.src = "", e.load());
+  }
+  get currentPlayer() {
+    return this.#t;
+  }
+  set currentPlayer(e) {
+    this.debugLog("set currentPlayer", e), this.#t && (this.#d(this.#t, !1), this.#t.load()), e && (this.#t = e, this.#d(e, !0));
+  }
+  get mediaElement() {
+    return this.currentPlayer ?? null;
+  }
+  get ready() {
+    return this.#o;
+  }
+  get volume() {
+    return L("desiredVolumeLevel");
+  }
+  set volume(e) {
+    this.debugLog("Setting volume to", e), this.currentPlayer && (this.currentPlayer.volume = e);
+  }
+}
+export {
+  f as default
+};