@tidal-music/player-web-components 0.1.0

package/dist/basePlayer-a-avZASH-Ux-6s9Ex.js

@@ -0,0 +1,579 @@
+import { _ as I, F as T, y as d, l as o, k as r, b as m, P as n, a as h, j as v, n as p, o as b, B as k, G as c, R as f, Q as A, c as g, w as P, d as y } from "./index-tM9JvbA8.js";
+function L(s) {
+  return g(
+    () => P(y, {
+      type: "play_log",
+      ...s
+    })
+  );
+}
+function N(s, t) {
+  return new CustomEvent(
+    "media-product-transition",
+    {
+      detail: {
+        mediaProduct: s,
+        playbackContext: t
+      }
+    }
+  );
+}
+const G = ({
+  assetPosition: s,
+  duration: t,
+  playbackInfo: e,
+  streamInfo: a
+}) => ({
+  actualAssetPresentation: e.assetPresentation,
+  actualAudioMode: "audioMode" in e ? e.audioMode : null,
+  actualAudioQuality: "audioQuality" in e ? e.audioQuality : null,
+  actualDuration: t,
+  actualProductId: String(
+    "videoId" in e ? e.videoId : e.trackId
+  ),
+  actualStreamType: "streamType" in e ? e.streamType : null,
+  actualVideoQuality: "videoQuality" in e ? e.videoQuality : null,
+  assetPosition: s,
+  bitDepth: a.bitDepth ?? null,
+  codec: a.codec ?? null,
+  playbackSessionId: a.streamingSessionId,
+  sampleRate: a.sampleRate ?? null
+});
+function M(s, t) {
+  return new CustomEvent("ended", {
+    detail: {
+      mediaProduct: t,
+      reason: s
+    }
+  });
+}
+function E(s) {
+  return new CustomEvent("playback-state-change", {
+    detail: {
+      state: s
+    }
+  });
+}
+function R() {
+  return new CustomEvent("preload-request");
+}
+const _ = {
+  playback: {
+    durationMS: 0,
+    id: "",
+    playedMS: 0,
+    source: {
+      id: "",
+      type: "playlist"
+    },
+    type: "TRACK"
+  }
+}, w = await I(
+  "progress",
+  _
+);
+function C(s) {
+  return w(s);
+}
+function D(s) {
+  return g(
+    () => P(y, {
+      ...s,
+      type: "playback"
+    })
+  );
+}
+function S(s) {
+  return Math.min(Math.pow(10, (4 + s) / 20), 1 / 1);
+}
+function x(s) {
+  switch (s) {
+    case "completed":
+      return "COMPLETE";
+    case "error":
+      return "ERROR";
+    case "skip":
+    default:
+      return "OTHER";
+  }
+}
+class Y {
+  #t;
+  #i;
+  #e;
+  #r = void 0;
+  #n;
+  #s = "IDLE";
+  #o;
+  #d;
+  #a = /* @__PURE__ */ new Map();
+  name;
+  constructor() {
+    T.addEventListener("desiredVolumeLevel", () => {
+      this.isActivePlayer && this.updateVolumeLevel();
+    });
+  }
+  // Implements
+  #c() {
+    this.duration && Math.abs(this.#i - this.duration) <= 30 && // A false check, rather than undefined, ensures a media product transition hs been made.
+    this.#r === !1 && (this.#r = !0, d.dispatchEvent(R()));
+  }
+  /**
+   * This method should be call whenever a playback ends, for **whatever** reason.
+   *
+   * ended, completed, skip, reset etc
+   */
+  #u({
+    endAssetPosition: t,
+    endReason: e,
+    streamingSessionId: a
+  }) {
+    this.debugLog("mediaProductEnded"), o.preloadedStreamingSessionId && performance.mark(
+      "streaming_metrics:playback_statistics:idealStartTimestamp",
+      {
+        detail: o.preloadedStreamingSessionId
+      }
+    );
+    const i = r.getMediaProductTransition(a);
+    i && d.dispatchEvent(
+      M(e, i.mediaProduct)
+    ), this.eventTrackingStreamingEnded(a, {
+      endAssetPosition: t,
+      endReason: e
+    }), this.reportPlaybackProgress(a), r.deleteSession(a), this.#a.delete(a), this.currentStreamingSessionId === a && (this.currentStreamingSessionId = void 0), this.updateVolumeLevelForNextProduct();
+  }
+  adjustedVolume(t) {
+    const e = m("desiredVolumeLevel"), a = m("loudnessNormalizationMode");
+    let i = e;
+    return a === "ALBUM" && t.albumReplayGain && (i *= S(t.albumReplayGain)), a === "TRACK" && t.trackReplayGain && (i *= S(t.trackReplayGain)), this.debugLog(
+      "adjustedVolume",
+      `Volume adjusted from ${e} to ${i}`
+    ), parseFloat(i.toFixed(2));
+  }
+  // Implements
+  attachPlaybackEngineEndedHandler() {
+    this.#e || (this.#e = this.playbackEngineEndedHandler.bind(this), d.addEventListener(
+      "ended",
+      this.#e
+    ));
+  }
+  /**
+   * Cleans up stored stream info and media product transitions
+   * for preloadedStreamingSessionId if it does not match
+   * currentStreamingSessionId.
+   */
+  cleanUpStoredPreloadInfo() {
+    this.preloadedStreamingSessionId && this.preloadedStreamingSessionId !== this.currentStreamingSessionId && (r.deleteSession(this.preloadedStreamingSessionId), this.preloadedStreamingSessionId = void 0);
+  }
+  // Implements
+  debugLog(...t) {
+    document.location.href.includes("localhost") && document.location.hash.includes("debug") && console.debug(
+      `[%cPlayerSDK${this.name ? `%c${o.activePlayer?.name === this.name ? "⚯" : "⚮"}%c` + this.name : ""}${this.#t ? "%c::%c" + this.#t?.split("-").pop() : ""}%c]`,
+      "color:#00d6ff",
+      ...this.name ? [
+        "color:inherit",
+        "color:#b7fa34"
+        // green foreground
+      ] : [],
+      ...this.#t ? [
+        "color:inherit",
+        "color:#d947ff"
+        // purple foreground
+      ] : [],
+      "color:inherit",
+      ...t
+    );
+  }
+  detachPlaybackEngineEndedHandler() {
+    this.#e && (d.removeEventListener(
+      "ended",
+      this.#e
+    ), this.#e = void 0);
+  }
+  /**
+   * Commits play_log playbackSession and streaming_metrics playbackStatistics.
+   *
+   * @param streamingSessionId
+   */
+  eventTrackingStreamingEnded(t, {
+    endAssetPosition: e,
+    endReason: a
+  }) {
+    const i = n.now();
+    L({
+      events: [
+        h({
+          endAssetPosition: e,
+          endTimestamp: i,
+          streamingSessionId: t
+        })
+      ]
+    }).catch(console.error), v({
+      events: [
+        p({
+          endReason: x(a),
+          endTimestamp: i,
+          streamingSessionId: t
+        }),
+        b({
+          streamingSessionId: t,
+          timestamp: i
+        })
+      ]
+    }).catch(console.error);
+  }
+  eventTrackingStreamingStarted(t) {
+    if (!t)
+      return;
+    performance.mark(
+      "streaming_metrics:playback_statistics:actualStartTimestamp",
+      {
+        detail: t
+      }
+    ), performance.measure("idealStartTimestamp -> actualStartTimestamp", {
+      detail: t,
+      end: "streaming_metrics:playback_statistics:actualStartTimestamp",
+      start: "streaming_metrics:playback_statistics:idealStartTimestamp"
+    });
+    try {
+      p({
+        actualStartTimestamp: n.timestamp(
+          "streaming_metrics:playback_statistics:actualStartTimestamp",
+          t
+        ),
+        idealStartTimestamp: n.timestamp(
+          "streaming_metrics:playback_statistics:idealStartTimestamp",
+          t
+        ),
+        outputDevice: this.#n,
+        streamingSessionId: t
+      });
+    } catch (l) {
+      console.error(
+        l,
+        "actualStartTimestamp or idealStartTimestamp is missing for this streaming session"
+      );
+    } finally {
+      performance.clearMarks(
+        "streaming_metrics:playback_statistics:actualStartTimestamp"
+      ), performance.clearMarks(
+        "streaming_metrics:playback_statistics:idealStartTimestamp"
+      );
+    }
+    const e = r.getMediaProductTransition(t);
+    if (!e) {
+      this.#a.has(t) ? console.error(
+        `A media product transition for streaming session #${t} has not been saved and could thus not be found for play log reporting.`
+      ) : (r.deleteStreamInfo(t), console.warn(
+        `Streaming session #${t} has been discarded due to a new load. This could mean you have a bug in your code where you call load on Player more than once time in a very short time frame.`
+      ));
+      return;
+    }
+    const { mediaProduct: a, playbackContext: i } = e, u = n.now();
+    h({
+      actualAssetPresentation: i.actualAssetPresentation,
+      actualAudioMode: "actualAudioMode" in i ? i.actualAudioMode : null,
+      actualProductId: i.actualProductId,
+      actualQuality: i.actualAudioQuality || i.actualVideoQuality,
+      isPostPaywall: i.actualAssetPresentation === "FULL",
+      playbackSessionId: t,
+      productType: a.productType === "track" ? "TRACK" : "VIDEO",
+      requestedProductId: a.productId,
+      sourceId: a.sourceId,
+      sourceType: a.sourceType,
+      startAssetPosition: this.startAssetPosition,
+      startTimestamp: u,
+      streamingSessionId: t
+    });
+  }
+  finishCurrentMediaProduct(t) {
+    const e = this.#t, a = e ? r.hasStreamInfo(e) : !1;
+    this.preloadedStreamingSessionId || (this.playbackState = "IDLE"), e && a && this.#u({
+      endAssetPosition: this.currentTime,
+      endReason: t,
+      streamingSessionId: e
+    });
+  }
+  getPosition() {
+    return 0;
+  }
+  /**
+   * Refetches playbackinfo.
+   */
+  async hardReload(t, e) {
+    return k(t, e);
+  }
+  hasNextItem() {
+    return this.preloadedStreamingSessionId && r.hasMediaProductTransition(
+      this.preloadedStreamingSessionId
+    );
+  }
+  hasStarted() {
+    return this.currentStreamingSessionId && this.#a.has(this.currentStreamingSessionId);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars, no-unused-vars
+  load(t, e) {
+    return Promise.resolve();
+  }
+  /**
+   * If playback info is prefetched or expired, do a hard reload.
+   *
+   * @returns {boolean} True if hard reloaded, else false.
+   */
+  async maybeHardReload() {
+    const t = this.prefetched || this.expired;
+    return this.currentMediaProduct && t ? (await this.hardReload(this.currentMediaProduct, 0), !0) : !1;
+  }
+  /**
+   * This method should be call whenever a playback starts, for **whatever** reason.
+   *
+   * skip, load.
+   *
+   * @param streamingSessionId
+   */
+  mediaProductStarted(t) {
+    !t || this.#a.has(t) || (this.debugLog("mediaProductStarted"), this.eventTrackingStreamingStarted(t), this.#a.set(t, !0), this.updateVolumeLevel(), this.#r = !1, this.preloadedStreamingSessionId = void 0, this.unloadPreloadedMediaProduct().catch(console.error), this.attachPlaybackEngineEndedHandler());
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars, no-unused-vars
+  next(t) {
+    return Promise.resolve();
+  }
+  /**
+   * When re-using a nexted item for a load, overwrite the nexted MediaProduct with the provided one.
+   * To ensure sourceId, sourceType and referenceId from the load call is correct for the playback -
+   * and not a stale incorrect one from the next call.
+   *
+   * @param streamingSessionId
+   * @param partialMediaProduct
+   */
+  overwriteMediaProduct(t, e) {
+    const a = r.getMediaProductTransition(t);
+    if (a) {
+      r.deleteMediaProductTransition(t);
+      const i = {
+        mediaProduct: {
+          ...a.mediaProduct,
+          ...e
+        },
+        playbackContext: {
+          ...a.playbackContext
+        }
+      };
+      r.saveMediaProductTransition(
+        t,
+        i
+      );
+    }
+  }
+  pause() {
+  }
+  play() {
+    return Promise.resolve();
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars, no-unused-vars
+  playbackEngineEndedHandler(t) {
+    return Promise.resolve();
+  }
+  reportPlaybackProgress(t) {
+    const e = r.getMediaProductTransition(t);
+    if (!e)
+      return;
+    const { mediaProduct: a, playbackContext: i } = e;
+    this.#t && D({
+      events: [
+        C({
+          playback: {
+            durationMS: Math.floor(i.actualDuration * 1e3),
+            id: a.productId,
+            playedMS: Math.floor(this.currentTime * 1e3),
+            source: {
+              id: a.sourceId,
+              type: a.sourceType
+            },
+            type: a.productType === "track" ? "TRACK" : "VIDEO"
+          },
+          streamingSessionId: this.#t
+        })
+      ]
+    }).catch(console.error);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  reset(t) {
+    return Promise.resolve();
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars, no-unused-vars
+  seek(t) {
+  }
+  /**
+   * Handle play log reporting for seeking.
+   * Seek start should log a PLAYBACK_START action if playing post seek.
+   */
+  seekEnd() {
+    this.currentStreamingSessionId && this.playbackState === "PLAYING" && c(this.currentStreamingSessionId, {
+      actionType: "PLAYBACK_START",
+      assetPosition: this.currentTime,
+      timestamp: n.now()
+    });
+  }
+  /**
+   * Handle play log reporting for seeking.
+   * Seek start should log a PLAYBACK_STOP action.
+   */
+  seekStart() {
+    this.currentStreamingSessionId && c(this.currentStreamingSessionId, {
+      actionType: "PLAYBACK_STOP",
+      assetPosition: this.currentTime,
+      timestamp: n.now()
+    });
+  }
+  async setStateToXIfNotYInZMs(t, e, a) {
+    await f(t), this.playbackState !== e && (this.playbackState = a);
+  }
+  skipToPreloadedMediaProduct() {
+    return Promise.resolve();
+  }
+  unloadPreloadedMediaProduct() {
+    return Promise.resolve();
+  }
+  updateOutputDevice() {
+    return Promise.resolve();
+  }
+  /**
+   * Hydrates the volume level from config, and adjusts
+   * it before setting, if loudness normalization is
+   * enabled.
+   */
+  updateVolumeLevel() {
+    const t = r.getStreamInfo(
+      this.currentStreamingSessionId
+    );
+    t && (this.volume = this.adjustedVolume(t));
+  }
+  /**
+   * Adjusts the volume for the next track.
+   * Can be called on product ended to have the level ready.
+   */
+  updateVolumeLevelForNextProduct() {
+    const t = r.getStreamInfo(
+      this.preloadedStreamingSessionId
+    );
+    t && (this.volume = this.adjustedVolume(t));
+  }
+  get currentMediaProduct() {
+    return r.getMediaProductTransition(
+      this.currentStreamingSessionId
+    )?.mediaProduct ?? null;
+  }
+  set currentStreamingSessionId(t) {
+    this.#t = t;
+  }
+  get currentStreamingSessionId() {
+    return this.#t;
+  }
+  set currentTime(t) {
+    this.#i = t, this.#c();
+  }
+  get currentTime() {
+    return this.#i;
+  }
+  get duration() {
+    const t = r.getMediaProductTransition(
+      this.currentStreamingSessionId
+    );
+    return t ? t.playbackContext.actualDuration : null;
+  }
+  get expired() {
+    const t = r.getStreamInfo(
+      this.currentStreamingSessionId
+    );
+    return t ? t.expires <= Date.now() : !1;
+  }
+  get isActivePlayer() {
+    return o.activePlayer && this.name === o.activePlayer.name;
+  }
+  get nextItem() {
+    if (this.preloadedStreamingSessionId)
+      return r.getMediaProductTransition(
+        this.preloadedStreamingSessionId
+      );
+  }
+  // eslint-disable-next-line accessor-pairs
+  set outputDeviceType(t) {
+    this.#n = t ? A(t) : void 0;
+  }
+  set playbackState(t) {
+    const e = this.#s;
+    if (e === t || !this.currentStreamingSessionId)
+      return;
+    const a = (u, l) => e === u && l === t;
+    switch (!0) {
+      case a("NOT_PLAYING", "STALLED"):
+      case a("IDLE", "STALLED"):
+        return;
+      case a("PLAYING", "NOT_PLAYING"):
+      case a("PLAYING", "IDLE"): {
+        this.reportPlaybackProgress(this.currentStreamingSessionId), console.debug(
+          "PS",
+          {
+            from: e,
+            to: t
+          },
+          {
+            currentTime: this.#i,
+            doIt: this.duration && this.currentTime < this.duration,
+            duration: this.duration
+          }
+        ), this.duration && this.currentTime < this.duration && c(this.currentStreamingSessionId, {
+          actionType: "PLAYBACK_STOP",
+          assetPosition: this.currentTime,
+          timestamp: n.now()
+        }).catch(console.error);
+        break;
+      }
+      case a("IDLE", "PLAYING"):
+      case a("NOT_PLAYING", "PLAYING"): {
+        this.currentTime !== this.startAssetPosition && c(this.currentStreamingSessionId, {
+          actionType: "PLAYBACK_START",
+          assetPosition: this.currentTime,
+          timestamp: n.now()
+        }).catch(console.error);
+        break;
+      }
+    }
+    this.#s = t, this.debugLog(`playbackState: ${t}`);
+    const i = o.activePlayer === void 0;
+    (this.isActivePlayer || i) && d.dispatchEvent(E(this.#s));
+  }
+  get playbackState() {
+    return this.#s;
+  }
+  get prefetched() {
+    const t = r.getStreamInfo(
+      this.currentStreamingSessionId
+    );
+    return t && t.prefetched;
+  }
+  set preloadedStreamingSessionId(t) {
+    this.#o = t;
+  }
+  get preloadedStreamingSessionId() {
+    return this.#o;
+  }
+  get startAssetPosition() {
+    return this.#d;
+  }
+  set startAssetPosition(t) {
+    this.#d = t;
+  }
+  // eslint-disable-next-line @typescript-eslint/class-literal-property-style
+  get volume() {
+    return 1;
+  }
+  set volume(t) {
+  }
+}
+export {
+  G as O,
+  N as V,
+  Y
+};