@hanifhan1f/vidstack 1.12.19 → 1.12.25

package/server/chunks/vidstack-BosyhF3p.js

@@ -0,0 +1,207 @@
+import { Host, effect, setAttribute, isString, BOOLEAN } from './vidstack-B8LynzY5.js';
+import { Poster, Thumbnail, Time, AirPlayButton, CaptionButton, FullscreenButton, LiveButton, MuteButton, PIPButton, PlayButton, SeekButton, AudioRadioGroup, CaptionsRadioGroup, Menu, MenuButton, MenuItem, MenuItems, SpeedRadioGroup, QualityRadioGroup, Radio, SliderValue, TimeSlider, SliderPreview, VolumeSlider } from './vidstack-PnFpou7g.js';
+import { useMediaContext, cloneTemplateContent, createTemplate, requestScopedAnimationFrame, cloneTemplate } from './vidstack-B4CWj0Hp.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);
+    }
+  }
+}
+
+const imgTemplate = /* @__PURE__ */ createTemplate(
+  '<img loading="eager" decoding="async" aria-hidden="true">'
+);
+class MediaThumbnailElement extends Host(HTMLElement, Thumbnail) {
+  static tagName = "media-thumbnail";
+  static attrs = {
+    crossOrigin: "crossorigin"
+  };
+  #media;
+  #img = this.#createImg();
+  onSetup() {
+    this.#media = useMediaContext();
+    this.$state.img.set(this.#img);
+  }
+  onConnect() {
+    const { src, crossOrigin } = this.$state;
+    if (this.#img.parentNode !== this) {
+      this.prepend(this.#img);
+    }
+    effect(() => {
+      setAttribute(this.#img, "src", src());
+      setAttribute(this.#img, "crossorigin", crossOrigin());
+    });
+  }
+  #createImg() {
+    return cloneTemplateContent(imgTemplate);
+  }
+}
+
+class MediaTimeElement extends Host(HTMLElement, Time) {
+  static tagName = "media-time";
+  onConnect() {
+    effect(() => {
+      this.textContent = this.$state.timeText();
+    });
+  }
+}
+
+class MediaAirPlayButtonElement extends Host(HTMLElement, AirPlayButton) {
+  static tagName = "media-airplay-button";
+}
+
+class MediaCaptionButtonElement extends Host(HTMLElement, CaptionButton) {
+  static tagName = "media-caption-button";
+}
+
+class MediaFullscreenButtonElement extends Host(HTMLElement, FullscreenButton) {
+  static tagName = "media-fullscreen-button";
+}
+
+class MediaLiveButtonElement extends Host(HTMLElement, LiveButton) {
+  static tagName = "media-live-button";
+}
+
+class MediaMuteButtonElement extends Host(HTMLElement, MuteButton) {
+  static tagName = "media-mute-button";
+}
+
+class MediaPIPButtonElement extends Host(HTMLElement, PIPButton) {
+  static tagName = "media-pip-button";
+}
+
+class MediaPlayButtonElement extends Host(HTMLElement, PlayButton) {
+  static tagName = "media-play-button";
+}
+
+class MediaSeekButtonElement extends Host(HTMLElement, SeekButton) {
+  static tagName = "media-seek-button";
+}
+
+function renderMenuItemsTemplate(el, onCreate) {
+  requestScopedAnimationFrame(() => {
+    if (!el.connectScope) return;
+    const template = el.querySelector("template");
+    if (!template) return;
+    effect(() => {
+      const options = el.getOptions();
+      cloneTemplate(template, options.length, (radio, i) => {
+        const { label, value } = options[i], labelEl = radio.querySelector(`[data-part="label"]`);
+        radio.setAttribute("value", value);
+        if (labelEl) {
+          if (isString(label)) {
+            labelEl.textContent = label;
+          } else {
+            effect(() => {
+              labelEl.textContent = label();
+            });
+          }
+        }
+        onCreate?.(radio, options[i], i);
+      });
+    });
+  });
+}
+
+class MediaAudioRadioGroupElement extends Host(HTMLElement, AudioRadioGroup) {
+  static tagName = "media-audio-radio-group";
+  onConnect() {
+    renderMenuItemsTemplate(this);
+  }
+}
+
+class MediaCaptionsRadioGroupElement extends Host(HTMLElement, CaptionsRadioGroup) {
+  static tagName = "media-captions-radio-group";
+  onConnect() {
+    renderMenuItemsTemplate(this);
+  }
+}
+
+class MediaMenuElement extends Host(HTMLElement, Menu) {
+  static tagName = "media-menu";
+}
+
+class MediaMenuButtonElement extends Host(HTMLElement, MenuButton) {
+  static tagName = "media-menu-button";
+}
+
+class MediaMenuItemElement extends Host(HTMLElement, MenuItem) {
+  static tagName = "media-menu-item";
+}
+
+class MediaMenuItemsElement extends Host(HTMLElement, MenuItems) {
+  static tagName = "media-menu-items";
+}
+
+class MediaSpeedRadioGroupElement extends Host(HTMLElement, SpeedRadioGroup) {
+  static tagName = "media-speed-radio-group";
+  onConnect() {
+    renderMenuItemsTemplate(this);
+  }
+}
+
+class MediaQualityRadioGroupElement extends Host(HTMLElement, QualityRadioGroup) {
+  static tagName = "media-quality-radio-group";
+  onConnect() {
+    renderMenuItemsTemplate(this, (el, option) => {
+      const bitrate = option.bitrate, bitrateEl = el.querySelector('[data-part="bitrate"]');
+      if (bitrate && bitrateEl) {
+        effect(() => {
+          bitrateEl.textContent = bitrate() || "";
+        });
+      }
+    });
+  }
+}
+
+class MediaRadioElement extends Host(HTMLElement, Radio) {
+  static tagName = "media-radio";
+}
+
+class MediaSliderValueElement extends Host(HTMLElement, SliderValue) {
+  static tagName = "media-slider-value";
+  static attrs = {
+    padMinutes: {
+      converter: BOOLEAN
+    }
+  };
+  onConnect() {
+    effect(() => {
+      this.textContent = this.getValueText();
+    });
+  }
+}
+
+class MediaTimeSliderElement extends Host(HTMLElement, TimeSlider) {
+  static tagName = "media-time-slider";
+}
+
+class MediaSliderPreviewElement extends Host(HTMLElement, SliderPreview) {
+  static tagName = "media-slider-preview";
+}
+
+class MediaVolumeSliderElement extends Host(HTMLElement, VolumeSlider) {
+  static tagName = "media-volume-slider";
+}
+
+export { MediaAirPlayButtonElement, MediaAudioRadioGroupElement, MediaCaptionButtonElement, MediaCaptionsRadioGroupElement, MediaFullscreenButtonElement, MediaLiveButtonElement, MediaMenuButtonElement, MediaMenuElement, MediaMenuItemElement, MediaMenuItemsElement, MediaMuteButtonElement, MediaPIPButtonElement, MediaPlayButtonElement, MediaPosterElement, MediaQualityRadioGroupElement, MediaRadioElement, MediaSeekButtonElement, MediaSliderPreviewElement, MediaSliderValueElement, MediaSpeedRadioGroupElement, MediaThumbnailElement, MediaTimeElement, MediaTimeSliderElement, MediaVolumeSliderElement, renderMenuItemsTemplate };

package/server/chunks/vidstack-C8F1EUBn.js

@@ -0,0 +1,104 @@
+import { Host, effect, computed, setAttribute } from './vidstack-B8LynzY5.js';
+import { MediaProvider, MediaPlayer } from './vidstack-DhF59-Up.js';
+import { useMediaContext } from './vidstack-B4CWj0Hp.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-DsnTqzpL.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/server/chunks/vidstack-CWho6PlG.js

@@ -0,0 +1,141 @@
+import { IS_CHROME } from './vidstack-DhF59-Up.js';
+import { loadScript } from './vidstack-B4CWj0Hp.js';
+import { peek } from './vidstack-B8LynzY5.js';
+import './vidstack-C19bj3Wq.js';
+import '@floating-ui/dom';
+
+function getCastFrameworkURL() {
+  return "https://www.gstatic.com/cv/js/sender/v1/cast_sender.js?loadCastFramework=1";
+}
+function hasLoadedCastFramework() {
+  return !!window.cast?.framework;
+}
+function isCastAvailable() {
+  return !!window.chrome?.cast?.isAvailable;
+}
+function isCastConnected() {
+  return getCastContext().getCastState() === cast.framework.CastState.CONNECTED;
+}
+function getCastContext() {
+  return window.cast.framework.CastContext.getInstance();
+}
+function getCastSession() {
+  return getCastContext().getCurrentSession();
+}
+function getDefaultCastOptions() {
+  return {
+    language: "en-US",
+    autoJoinPolicy: chrome.cast.AutoJoinPolicy.ORIGIN_SCOPED,
+    receiverApplicationId: chrome.cast.media.DEFAULT_MEDIA_RECEIVER_APP_ID,
+    resumeSavedSession: true,
+    androidReceiverCompatible: true
+  };
+}
+function getCastErrorMessage(code) {
+  const defaultMessage = `Google Cast Error Code: ${code}`;
+  return defaultMessage;
+}
+
+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;
+  }
+  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) {
+    {
+      throw Error("[vidstack] can not load google cast provider server-side");
+    }
+  }
+  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 };