@hanifhan1f/vidstack 1.12.25 → 1.12.27

package/prod/chunks/vidstack-sP7TQMB1.js

@@ -0,0 +1,300 @@
+import { listenEvent, scoped, isString, getScope, EventsTarget, DOMEvent, isArray, isNumber } from './vidstack-BNpgCJJ1.js';
+import { getRequestCredentials } from './vidstack-KShKSmYu.js';
+
+const CROSS_ORIGIN = Symbol(0), READY_STATE = Symbol(0), UPDATE_ACTIVE_CUES = Symbol(0), CAN_LOAD = Symbol(0), ON_MODE_CHANGE = Symbol(0), NATIVE = Symbol(0), NATIVE_HLS = Symbol(0);
+const TextTrackSymbol = {
+  crossOrigin: CROSS_ORIGIN,
+  readyState: READY_STATE,
+  updateActiveCues: UPDATE_ACTIVE_CUES,
+  canLoad: CAN_LOAD,
+  onModeChange: ON_MODE_CHANGE,
+  native: NATIVE,
+  nativeHLS: NATIVE_HLS
+};
+
+function findActiveCue(cues, time) {
+  for (let i = 0, len = cues.length; i < len; i++) {
+    if (isCueActive(cues[i], time)) return cues[i];
+  }
+  return null;
+}
+function isCueActive(cue, time) {
+  return time >= cue.startTime && time < cue.endTime;
+}
+function watchActiveTextTrack(tracks, kind, onChange) {
+  let currentTrack = null, scope = getScope();
+  function onModeChange() {
+    const kinds = isString(kind) ? [kind] : kind, track = tracks.toArray().find((track2) => kinds.includes(track2.kind) && track2.mode === "showing");
+    if (track === currentTrack) return;
+    if (!track) {
+      onChange(null);
+      currentTrack = null;
+      return;
+    }
+    if (track.readyState == 2) {
+      onChange(track);
+    } else {
+      onChange(null);
+      scoped(() => {
+        const off = listenEvent(
+          track,
+          "load",
+          () => {
+            onChange(track);
+            off();
+          },
+          { once: true }
+        );
+      }, scope);
+    }
+    currentTrack = track;
+  }
+  onModeChange();
+  return listenEvent(tracks, "mode-change", onModeChange);
+}
+function watchCueTextChange(tracks, kind, callback) {
+  watchActiveTextTrack(tracks, kind, (track) => {
+    if (!track) {
+      callback("");
+      return;
+    }
+    const onCueChange = () => {
+      const activeCue = track?.activeCues[0];
+      callback(activeCue?.text || "");
+    };
+    onCueChange();
+    listenEvent(track, "cue-change", onCueChange);
+  });
+}
+
+class TextTrack extends EventsTarget {
+  static createId(track) {
+    return `vds-${track.type}-${track.kind}-${track.src ?? track.label ?? "?"}`;
+  }
+  src;
+  content;
+  type;
+  encoding;
+  id = "";
+  label = "";
+  language = "";
+  kind;
+  default = false;
+  #canLoad = false;
+  #currentTime = 0;
+  #mode = "disabled";
+  #metadata = {};
+  #regions = [];
+  #cues = [];
+  #activeCues = [];
+  #cueIds = /* @__PURE__ */ new Set();
+  /** @internal */
+  [TextTrackSymbol.readyState] = 0;
+  /** @internal */
+  [TextTrackSymbol.crossOrigin];
+  /** @internal */
+  [TextTrackSymbol.onModeChange] = null;
+  /** @internal */
+  [TextTrackSymbol.native] = null;
+  get metadata() {
+    return this.#metadata;
+  }
+  get regions() {
+    return this.#regions;
+  }
+  get cues() {
+    return this.#cues;
+  }
+  get activeCues() {
+    return this.#activeCues;
+  }
+  /**
+   * - 0: Not Loading
+   * - 1: Loading
+   * - 2: Ready
+   * - 3: Error
+   */
+  get readyState() {
+    return this[TextTrackSymbol.readyState];
+  }
+  get mode() {
+    return this.#mode;
+  }
+  set mode(mode) {
+    this.setMode(mode);
+  }
+  constructor(init) {
+    super();
+    for (const prop of Object.keys(init)) this[prop] = init[prop];
+    if (!this.type) this.type = "vtt";
+    if (init.content) {
+      this.#parseContent(init);
+    } else if (!init.src) {
+      this[TextTrackSymbol.readyState] = 2;
+    }
+  }
+  addCue(cue, trigger) {
+    if (cue.id) {
+      if (this.#cueIds.has(cue.id)) return;
+      this.#cueIds.add(cue.id);
+    }
+    let i = 0, length = this.#cues.length;
+    for (i = 0; i < length; i++) if (cue.endTime <= this.#cues[i].startTime) break;
+    if (i === length) this.#cues.push(cue);
+    else this.#cues.splice(i, 0, cue);
+    if (!(cue instanceof TextTrackCue)) {
+      this[TextTrackSymbol.native]?.track.addCue(cue);
+    }
+    this.dispatchEvent(new DOMEvent("add-cue", { detail: cue, trigger }));
+    if (isCueActive(cue, this.#currentTime)) {
+      this[TextTrackSymbol.updateActiveCues](this.#currentTime, trigger);
+    }
+  }
+  removeCue(cue, trigger) {
+    const index = this.#cues.indexOf(cue);
+    if (index >= 0) {
+      const isActive = this.#activeCues.includes(cue);
+      if (cue.id) this.#cueIds.delete(cue.id);
+      this.#cues.splice(index, 1);
+      this[TextTrackSymbol.native]?.track.removeCue(cue);
+      this.dispatchEvent(new DOMEvent("remove-cue", { detail: cue, trigger }));
+      if (isActive) {
+        this[TextTrackSymbol.updateActiveCues](this.#currentTime, trigger);
+      }
+    }
+  }
+  setMode(mode, trigger) {
+    if (this.#mode === mode) return;
+    this.#mode = mode;
+    if (mode === "disabled") {
+      this.#activeCues = [];
+      this.#activeCuesChanged();
+    } else if (this.readyState === 2) {
+      this[TextTrackSymbol.updateActiveCues](this.#currentTime, trigger);
+    } else {
+      this.#load();
+    }
+    this.dispatchEvent(new DOMEvent("mode-change", { detail: this, trigger }));
+    this[TextTrackSymbol.onModeChange]?.();
+  }
+  /** @internal */
+  [TextTrackSymbol.updateActiveCues](currentTime, trigger) {
+    this.#currentTime = currentTime;
+    if (this.mode === "disabled" || !this.#cues.length) return;
+    const activeCues = [];
+    for (let i = 0, length = this.#cues.length; i < length; i++) {
+      const cue = this.#cues[i];
+      if (isCueActive(cue, currentTime)) activeCues.push(cue);
+    }
+    let changed = activeCues.length !== this.#activeCues.length;
+    if (!changed) {
+      for (let i = 0; i < activeCues.length; i++) {
+        if (!this.#activeCues.includes(activeCues[i])) {
+          changed = true;
+          break;
+        }
+      }
+    }
+    this.#activeCues = activeCues;
+    if (changed) this.#activeCuesChanged(trigger);
+  }
+  /** @internal */
+  [TextTrackSymbol.canLoad]() {
+    this.#canLoad = true;
+    if (this.#mode !== "disabled") this.#load();
+  }
+  #parseContent(init) {
+    import('media-captions').then(({ parseText, VTTCue, VTTRegion }) => {
+      if (!isString(init.content) || init.type === "json") {
+        this.#parseJSON(init.content, VTTCue, VTTRegion);
+        if (this.readyState !== 3) this.#ready();
+      } else {
+        const content = init.content.split("\n").map((line) => line.trim()).join("\n").trim();
+        parseText(content, { type: init.type }).then(({ cues, regions }) => {
+          this.#cues = cues;
+          this.#regions = regions;
+          this.#ready();
+        });
+      }
+    });
+  }
+  async #load() {
+    if (!this.#canLoad || this[TextTrackSymbol.readyState] > 0) return;
+    this[TextTrackSymbol.readyState] = 1;
+    this.dispatchEvent(new DOMEvent("load-start"));
+    if (!this.src) {
+      this.#ready();
+      return;
+    }
+    try {
+      const { parseResponse, VTTCue, VTTRegion } = await import('media-captions'), crossOrigin = this[TextTrackSymbol.crossOrigin]?.();
+      const response = fetch(this.src, {
+        headers: this.type === "json" ? { "Content-Type": "application/json" } : void 0,
+        credentials: getRequestCredentials(crossOrigin)
+      });
+      if (this.type === "json") {
+        this.#parseJSON(await (await response).text(), VTTCue, VTTRegion);
+      } else {
+        const { errors, metadata, regions, cues } = await parseResponse(response, {
+          type: this.type,
+          encoding: this.encoding
+        });
+        if (errors[0]?.code === 0) {
+          throw errors[0];
+        } else {
+          this.#metadata = metadata;
+          this.#regions = regions;
+          this.#cues = cues;
+        }
+      }
+      this.#ready();
+    } catch (error) {
+      this.#error(error);
+    }
+  }
+  #ready() {
+    this[TextTrackSymbol.readyState] = 2;
+    if (!this.src || this.type !== "vtt") {
+      const native = this[TextTrackSymbol.native];
+      if (native && !native.managed) {
+        for (const cue of this.#cues) native.track.addCue(cue);
+      }
+    }
+    const loadEvent = new DOMEvent("load");
+    this[TextTrackSymbol.updateActiveCues](this.#currentTime, loadEvent);
+    this.dispatchEvent(loadEvent);
+  }
+  #error(error) {
+    this[TextTrackSymbol.readyState] = 3;
+    this.dispatchEvent(new DOMEvent("error", { detail: error }));
+  }
+  #parseJSON(json, VTTCue, VTTRegion) {
+    try {
+      const { regions, cues } = parseJSONCaptionsFile(json, VTTCue, VTTRegion);
+      this.#regions = regions;
+      this.#cues = cues;
+    } catch (error) {
+      this.#error(error);
+    }
+  }
+  #activeCuesChanged(trigger) {
+    this.dispatchEvent(new DOMEvent("cue-change", { trigger }));
+  }
+}
+const captionRE = /captions|subtitles/;
+function isTrackCaptionKind(track) {
+  return captionRE.test(track.kind);
+}
+function parseJSONCaptionsFile(json, Cue, Region) {
+  const content = isString(json) ? JSON.parse(json) : json;
+  let regions = [], cues = [];
+  if (content.regions && Region) {
+    regions = content.regions.map((region) => Object.assign(new Region(), region));
+  }
+  if (content.cues || isArray(content)) {
+    cues = (isArray(content) ? content : content.cues).filter((content2) => isNumber(content2.startTime) && isNumber(content2.endTime)).map((cue) => Object.assign(new Cue(0, 0, ""), cue));
+  }
+  return { regions, cues };
+}
+
+export { TextTrack, TextTrackSymbol, findActiveCue, isCueActive, isTrackCaptionKind, parseJSONCaptionsFile, watchActiveTextTrack, watchCueTextChange };

package/prod/chunks/vidstack-uVm3xX8H.js

@@ -0,0 +1,104 @@
+import { Host, effect, computed, setAttribute } from './vidstack-BNpgCJJ1.js';
+import { MediaProvider, MediaPlayer } from './vidstack-CLTPjjXX.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 };