@hanifhan1f/vidstack 1.12.19 → 1.12.24

package/prod/chunks/vidstack-Bf1Q6kqO.js

@@ -0,0 +1,109 @@
+import { IS_CHROME, IS_IOS, canGoogleCastSrc } from './vidstack-wTTCvdqe.js';
+import { loadScript } from './vidstack-KShKSmYu.js';
+import { getCastContext, getCastSession, isCastConnected, hasLoadedCastFramework, getCastFrameworkURL, isCastAvailable, getCastErrorMessage, getDefaultCastOptions } from './vidstack-9_r3lWNO.js';
+import { peek } from './vidstack-BNpgCJJ1.js';
+
+class GoogleCastLoader {
+  name = "google-cast";
+  target;
+  #player;
+  /**
+   * @see {@link https://developers.google.com/cast/docs/reference/web_sender/cast.framework.CastContext}
+   */
+  get cast() {
+    return getCastContext();
+  }
+  mediaType() {
+    return "video";
+  }
+  canPlay(src) {
+    return IS_CHROME && !IS_IOS && canGoogleCastSrc(src);
+  }
+  async prompt(ctx) {
+    let loadEvent, openEvent, errorEvent;
+    try {
+      loadEvent = await this.#loadCastFramework(ctx);
+      if (!this.#player) {
+        this.#player = new cast.framework.RemotePlayer();
+        new cast.framework.RemotePlayerController(this.#player);
+      }
+      openEvent = ctx.player.createEvent("google-cast-prompt-open", {
+        trigger: loadEvent
+      });
+      ctx.player.dispatchEvent(openEvent);
+      this.#notifyRemoteStateChange(ctx, "connecting", openEvent);
+      await this.#showPrompt(peek(ctx.$props.googleCast));
+      ctx.$state.remotePlaybackInfo.set({
+        deviceName: getCastSession()?.getCastDevice().friendlyName
+      });
+      if (isCastConnected()) this.#notifyRemoteStateChange(ctx, "connected", openEvent);
+    } catch (code) {
+      const error = code instanceof Error ? code : this.#createError(
+        (code + "").toUpperCase(),
+        "Prompt failed."
+      );
+      errorEvent = ctx.player.createEvent("google-cast-prompt-error", {
+        detail: error,
+        trigger: openEvent ?? loadEvent,
+        cancelable: true
+      });
+      ctx.player.dispatch(errorEvent);
+      this.#notifyRemoteStateChange(
+        ctx,
+        isCastConnected() ? "connected" : "disconnected",
+        errorEvent
+      );
+      throw error;
+    } finally {
+      ctx.player.dispatch("google-cast-prompt-close", {
+        trigger: errorEvent ?? openEvent ?? loadEvent
+      });
+    }
+  }
+  async load(ctx) {
+    if (!this.#player) {
+      throw Error("[vidstack] google cast player was not initialized");
+    }
+    return new (await import('../providers/vidstack-google-cast.js')).GoogleCastProvider(this.#player, ctx);
+  }
+  async #loadCastFramework(ctx) {
+    if (hasLoadedCastFramework()) return;
+    const loadStartEvent = ctx.player.createEvent("google-cast-load-start");
+    ctx.player.dispatch(loadStartEvent);
+    await loadScript(getCastFrameworkURL());
+    await customElements.whenDefined("google-cast-launcher");
+    const loadedEvent = ctx.player.createEvent("google-cast-loaded", { trigger: loadStartEvent });
+    ctx.player.dispatch(loadedEvent);
+    if (!isCastAvailable()) {
+      throw this.#createError("CAST_NOT_AVAILABLE", "Google Cast not available on this platform.");
+    }
+    return loadedEvent;
+  }
+  async #showPrompt(options) {
+    this.#setOptions(options);
+    const errorCode = await this.cast.requestSession();
+    if (errorCode) {
+      throw this.#createError(
+        errorCode.toUpperCase(),
+        getCastErrorMessage(errorCode)
+      );
+    }
+  }
+  #setOptions(options) {
+    this.cast?.setOptions({
+      ...getDefaultCastOptions(),
+      ...options
+    });
+  }
+  #notifyRemoteStateChange(ctx, state, trigger) {
+    const detail = { type: "google-cast", state };
+    ctx.notify("remote-playback-change", detail, trigger);
+  }
+  #createError(code, message) {
+    const error = Error(message);
+    error.code = code;
+    return error;
+  }
+}
+
+export { GoogleCastLoader };

package/prod/chunks/vidstack-Bn9yLryd.js

@@ -0,0 +1,58 @@
+import { signal, effect, listenEvent, EventsController } from './vidstack-BNpgCJJ1.js';
+import './vidstack-wTTCvdqe.js';
+
+class HTMLRemotePlaybackAdapter {
+  #media;
+  #ctx;
+  #state;
+  #supported = signal(false);
+  get supported() {
+    return this.#supported();
+  }
+  constructor(media, ctx) {
+    this.#media = media;
+    this.#ctx = ctx;
+    this.#setup();
+  }
+  #setup() {
+    if (!this.#media?.remote || !this.canPrompt) return;
+    this.#media.remote.watchAvailability((available) => {
+      this.#supported.set(available);
+    }).catch(() => {
+      this.#supported.set(false);
+    });
+    effect(this.#watchSupported.bind(this));
+  }
+  #watchSupported() {
+    if (!this.#supported()) return;
+    const events = ["connecting", "connect", "disconnect"], onStateChange = this.#onStateChange.bind(this);
+    onStateChange();
+    listenEvent(this.#media, "playing", onStateChange);
+    const remoteEvents = new EventsController(this.#media.remote);
+    for (const type of events) {
+      remoteEvents.add(type, onStateChange);
+    }
+  }
+  async prompt() {
+    if (!this.supported) throw Error("Not supported on this platform.");
+    if (this.type === "airplay" && this.#media.webkitShowPlaybackTargetPicker) {
+      return this.#media.webkitShowPlaybackTargetPicker();
+    }
+    return this.#media.remote.prompt();
+  }
+  #onStateChange(event) {
+    const state = this.#media.remote.state;
+    if (state === this.#state) return;
+    const detail = { type: this.type, state };
+    this.#ctx.notify("remote-playback-change", detail, event);
+    this.#state = state;
+  }
+}
+class HTMLAirPlayAdapter extends HTMLRemotePlaybackAdapter {
+  type = "airplay";
+  get canPrompt() {
+    return "WebKitPlaybackTargetAvailabilityEvent" in window;
+  }
+}
+
+export { HTMLAirPlayAdapter };

package/prod/chunks/vidstack-C4PTiuot.js

@@ -0,0 +1,107 @@
+import { Component, State, effect, isNull, setAttribute, EventsController } from './vidstack-BNpgCJJ1.js';
+import { useMediaContext } from './vidstack-tt3O1zL6.js';
+import { preconnect } from './vidstack-KShKSmYu.js';
+
+class Poster extends Component {
+  static props = {
+    src: null,
+    alt: null,
+    crossOrigin: null
+  };
+  static state = new State({
+    img: null,
+    src: null,
+    alt: null,
+    crossOrigin: null,
+    loading: true,
+    error: null,
+    hidden: false
+  });
+  #media;
+  onSetup() {
+    this.#media = useMediaContext();
+    this.#watchSrc();
+    this.#watchAlt();
+    this.#watchCrossOrigin();
+    this.#watchHidden();
+  }
+  onAttach(el) {
+    el.style.setProperty("pointer-events", "none");
+    effect(this.#watchImg.bind(this));
+    effect(this.#watchSrc.bind(this));
+    effect(this.#watchAlt.bind(this));
+    effect(this.#watchCrossOrigin.bind(this));
+    effect(this.#watchHidden.bind(this));
+    const { started } = this.#media.$state;
+    this.setAttributes({
+      "data-visible": () => !started() && !this.$state.hidden(),
+      "data-loading": this.#isLoading.bind(this),
+      "data-error": this.#hasError.bind(this),
+      "data-hidden": this.$state.hidden
+    });
+  }
+  onConnect(el) {
+    effect(this.#onPreconnect.bind(this));
+    effect(this.#onLoadStart.bind(this));
+  }
+  #hasError() {
+    const { error } = this.$state;
+    return !isNull(error());
+  }
+  #onPreconnect() {
+    const { canLoadPoster, poster } = this.#media.$state;
+    if (!canLoadPoster() && poster()) preconnect(poster(), "preconnect");
+  }
+  #watchHidden() {
+    const { src } = this.$props, { poster, nativeControls } = this.#media.$state;
+    this.el && setAttribute(this.el, "display", nativeControls() ? "none" : null);
+    this.$state.hidden.set(this.#hasError() || !(src() || poster()) || nativeControls());
+  }
+  #isLoading() {
+    const { loading, hidden } = this.$state;
+    return !hidden() && loading();
+  }
+  #watchImg() {
+    const img = this.$state.img();
+    if (!img) return;
+    new EventsController(img).add("load", this.#onLoad.bind(this)).add("error", this.#onError.bind(this));
+    if (img.complete) this.#onLoad();
+  }
+  #prevSrc = "";
+  #watchSrc() {
+    const { poster: defaultPoster } = this.#media.$props, { canLoadPoster, providedPoster, inferredPoster } = this.#media.$state;
+    const src = this.$props.src() || "", poster = src || defaultPoster() || inferredPoster();
+    if (this.#prevSrc === providedPoster()) {
+      providedPoster.set(src);
+    }
+    this.$state.src.set(canLoadPoster() && poster.length ? poster : null);
+    this.#prevSrc = src;
+  }
+  #watchAlt() {
+    const { src } = this.$props, { alt } = this.$state, { poster } = this.#media.$state;
+    alt.set(src() || poster() ? this.$props.alt() : null);
+  }
+  #watchCrossOrigin() {
+    const { crossOrigin: crossOriginProp } = this.$props, { crossOrigin: crossOriginState } = this.$state, { crossOrigin: mediaCrossOrigin, poster: src } = this.#media.$state, crossOrigin = crossOriginProp() !== null ? crossOriginProp() : mediaCrossOrigin();
+    crossOriginState.set(
+      /ytimg\.com|vimeo/.test(src() || "") ? null : crossOrigin === true ? "anonymous" : crossOrigin
+    );
+  }
+  #onLoadStart() {
+    const { loading, error } = this.$state, { canLoadPoster, poster } = this.#media.$state;
+    loading.set(canLoadPoster() && !!poster());
+    error.set(null);
+  }
+  #onLoad() {
+    const { loading, error } = this.$state;
+    loading.set(false);
+    error.set(null);
+  }
+  #onError(event) {
+    const { loading, error } = this.$state;
+    loading.set(false);
+    error.set(event);
+  }
+}
+
+export { Poster };

package/prod/chunks/vidstack-DMDDSV3t.js

@@ -0,0 +1,104 @@
+import { Host, effect, computed, setAttribute } from './vidstack-BNpgCJJ1.js';
+import { MediaProvider, MediaPlayer } from './vidstack-BAqdCFIm.js';
+import { useMediaContext } from './vidstack-tt3O1zL6.js';
+
+class MediaProviderElement extends Host(HTMLElement, MediaProvider) {
+  static tagName = "media-provider";
+  #media;
+  #target = null;
+  #blocker = null;
+  onSetup() {
+    this.#media = useMediaContext();
+    this.setAttribute("keep-alive", "");
+  }
+  onDestroy() {
+    this.#blocker?.remove();
+    this.#blocker = null;
+    this.#target?.remove();
+    this.#target = null;
+  }
+  onConnect() {
+    effect(() => {
+      const loader = this.$state.loader(), isYouTubeEmbed = loader?.name === "youtube", isVimeoEmbed = loader?.name === "vimeo", isEmbed = isYouTubeEmbed || isVimeoEmbed, isGoogleCast = loader?.name === "google-cast";
+      const target = loader ? isGoogleCast ? this.#createGoogleCastContainer() : isEmbed ? this.#createIFrame() : loader.mediaType() === "audio" ? this.#createAudio() : this.#createVideo() : null;
+      if (this.#target !== target) {
+        const parent = this.#target?.parentElement ?? this;
+        this.#target?.remove();
+        this.#target = target;
+        if (target) parent.prepend(target);
+        if (isEmbed && target) {
+          effect(() => {
+            const { nativeControls, viewType } = this.#media.$state, showNativeControls = nativeControls(), isAudioView = viewType() === "audio", showBlocker = !showNativeControls && !isAudioView;
+            if (showBlocker) {
+              this.#blocker = this.querySelector(".vds-blocker");
+              if (!this.#blocker) {
+                this.#blocker = document.createElement("div");
+                this.#blocker.classList.add("vds-blocker");
+                target.after(this.#blocker);
+              }
+            } else {
+              this.#blocker?.remove();
+              this.#blocker = null;
+            }
+            setAttribute(target, "data-no-controls", !showNativeControls);
+          });
+        }
+      }
+      if (isYouTubeEmbed) target?.classList.add("vds-youtube");
+      else if (isVimeoEmbed) target?.classList.add("vds-vimeo");
+      if (!isEmbed) {
+        this.#blocker?.remove();
+        this.#blocker = null;
+      }
+      this.load(target);
+    });
+  }
+  #createAudio() {
+    const audio = this.#target instanceof HTMLAudioElement ? this.#target : document.createElement("audio");
+    const { controls, crossOrigin } = this.#media.$state;
+    effect(() => {
+      setAttribute(audio, "controls", controls());
+      setAttribute(audio, "crossorigin", crossOrigin());
+    });
+    return audio;
+  }
+  #createVideo() {
+    const video = this.#target instanceof HTMLVideoElement ? this.#target : document.createElement("video");
+    const { crossOrigin, poster, nativeControls } = this.#media.$state, $controls = computed(() => nativeControls() ? "true" : null), $poster = computed(() => poster() && nativeControls() ? poster() : null);
+    effect(() => {
+      setAttribute(video, "controls", $controls());
+      setAttribute(video, "crossorigin", crossOrigin());
+      setAttribute(video, "poster", $poster());
+    });
+    return video;
+  }
+  #createIFrame() {
+    const iframe = this.#target instanceof HTMLIFrameElement ? this.#target : document.createElement("iframe"), { nativeControls } = this.#media.$state;
+    effect(() => setAttribute(iframe, "tabindex", !nativeControls() ? -1 : null));
+    return iframe;
+  }
+  #createGoogleCastContainer() {
+    if (this.#target?.classList.contains("vds-google-cast")) {
+      return this.#target;
+    }
+    const container = document.createElement("div");
+    container.classList.add("vds-google-cast");
+    import('./vidstack-Oq65llxr.js').then(({ insertContent }) => {
+      insertContent(container, this.#media.$state);
+    });
+    return container;
+  }
+}
+
+class MediaPlayerElement extends Host(HTMLElement, MediaPlayer) {
+  static tagName = "media-player";
+  static attrs = {
+    autoPlay: "autoplay",
+    crossOrigin: "crossorigin",
+    playsInline: "playsinline",
+    preferNativeHLS: "prefer-native-hls",
+    minLiveDVRWindow: "min-live-dvr-window"
+  };
+}
+
+export { MediaPlayerElement, MediaProviderElement };

package/prod/chunks/vidstack-Dg71uhRc.js

@@ -0,0 +1,58 @@
+import { signal, listenEvent, effect, peek, isString } from './vidstack-BNpgCJJ1.js';
+import { appendParamsToURL } from './vidstack-KShKSmYu.js';
+
+class EmbedProvider {
+  #iframe;
+  src = signal("");
+  /**
+   * Defines which referrer is sent when fetching the resource.
+   *
+   * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/HTMLIFrameElement/referrerPolicy}
+   */
+  referrerPolicy = null;
+  get iframe() {
+    return this.#iframe;
+  }
+  constructor(iframe) {
+    this.#iframe = iframe;
+    iframe.setAttribute("frameBorder", "0");
+    iframe.setAttribute("aria-hidden", "true");
+    iframe.setAttribute(
+      "allow",
+      "autoplay; fullscreen; encrypted-media; picture-in-picture; accelerometer; gyroscope"
+    );
+    if (this.referrerPolicy !== null) {
+      iframe.setAttribute("referrerpolicy", this.referrerPolicy);
+    }
+  }
+  setup() {
+    listenEvent(window, "message", this.#onWindowMessage.bind(this));
+    listenEvent(this.#iframe, "load", this.onLoad.bind(this));
+    effect(this.#watchSrc.bind(this));
+  }
+  #watchSrc() {
+    const src = this.src();
+    if (!src.length) {
+      this.#iframe.setAttribute("src", "");
+      return;
+    }
+    const params = peek(() => this.buildParams());
+    this.#iframe.setAttribute("src", appendParamsToURL(src, params));
+  }
+  postMessage(message, target) {
+    this.#iframe.contentWindow?.postMessage(JSON.stringify(message), target ?? "*");
+  }
+  #onWindowMessage(event) {
+    const origin = this.getOrigin(), isOriginMatch = (event.source === null || event.source === this.#iframe?.contentWindow) && (!isString(origin) || origin === event.origin);
+    if (!isOriginMatch) return;
+    try {
+      const message = JSON.parse(event.data);
+      if (message) this.onMessage(message, event);
+      return;
+    } catch (e) {
+    }
+    if (event.data) this.onMessage(event.data, event);
+  }
+}
+
+export { EmbedProvider };

package/prod/chunks/vidstack-DlLwMLBL.js

@@ -0,0 +1,33 @@
+import { Host, effect, setAttribute } from './vidstack-BNpgCJJ1.js';
+import { Poster } from './vidstack-C4PTiuot.js';
+import './vidstack-tt3O1zL6.js';
+import './vidstack-KShKSmYu.js';
+import './vidstack-wTTCvdqe.js';
+
+class MediaPosterElement extends Host(HTMLElement, Poster) {
+  static tagName = "media-poster";
+  static attrs = {
+    crossOrigin: "crossorigin"
+  };
+  #img = document.createElement("img");
+  onSetup() {
+    this.$state.img.set(this.#img);
+  }
+  onConnect() {
+    const { src, alt, crossOrigin } = this.$state;
+    effect(() => {
+      const { loading, hidden } = this.$state;
+      this.#img.style.display = loading() || hidden() ? "none" : "";
+    });
+    effect(() => {
+      setAttribute(this.#img, "alt", alt());
+      setAttribute(this.#img, "crossorigin", crossOrigin());
+      setAttribute(this.#img, "src", src());
+    });
+    if (this.#img.parentNode !== this) {
+      this.prepend(this.#img);
+    }
+  }
+}
+
+export { MediaPosterElement };

package/prod/chunks/vidstack-KShKSmYu.js

@@ -0,0 +1,66 @@
+import { isNull, isString, deferredPromise, isBoolean } from './vidstack-BNpgCJJ1.js';
+import { isAudioSrc, isVideoSrc } from './vidstack-wTTCvdqe.js';
+
+function appendParamsToURL(baseUrl, params) {
+  const url = new URL(baseUrl);
+  for (const key of Object.keys(params)) {
+    url.searchParams.set(key, params[key] + "");
+  }
+  return url.toString();
+}
+function preconnect(url, rel = "preconnect") {
+  const exists = document.querySelector(`link[href="${url}"]`);
+  if (!isNull(exists)) return true;
+  const link = document.createElement("link");
+  link.rel = rel;
+  link.href = url;
+  link.crossOrigin = "true";
+  document.head.append(link);
+  return true;
+}
+const pendingRequests = {};
+function loadScript(src) {
+  if (pendingRequests[src]) return pendingRequests[src].promise;
+  const promise = deferredPromise(), exists = document.querySelector(`script[src="${src}"]`);
+  if (!isNull(exists)) {
+    promise.resolve();
+    return promise.promise;
+  }
+  pendingRequests[src] = promise;
+  const script = document.createElement("script");
+  script.src = src;
+  script.onload = () => {
+    promise.resolve();
+    delete pendingRequests[src];
+  };
+  script.onerror = () => {
+    promise.reject();
+    delete pendingRequests[src];
+  };
+  setTimeout(() => document.head.append(script), 0);
+  return promise.promise;
+}
+function getRequestCredentials(crossOrigin) {
+  return crossOrigin === "use-credentials" ? "include" : isString(crossOrigin) ? "same-origin" : void 0;
+}
+function getDownloadFile({
+  title,
+  src,
+  download
+}) {
+  const url = isBoolean(download) || download === "" ? src.src : isString(download) ? download : download?.url;
+  if (!isValidFileDownload({ url, src, download })) return null;
+  return {
+    url,
+    name: !isBoolean(download) && !isString(download) && download?.filename || title.toLowerCase() || "media"
+  };
+}
+function isValidFileDownload({
+  url,
+  src,
+  download
+}) {
+  return isString(url) && (download && download !== true || isAudioSrc(src) || isVideoSrc(src));
+}
+
+export { appendParamsToURL, getDownloadFile, getRequestCredentials, loadScript, preconnect };