@scarlett-player/embed 0.5.3 → 1.0.1

package/dist/embed.js

@@ -43,6 +43,18 @@ function mapLevels(levels, _currentLevel) {
     codec: level.codecSet
   }));
 }
+function getInitialBandwidthEstimate(overrideBps) {
+  const HLS_DEFAULT_ESTIMATE = 5e5;
+  if (overrideBps !== void 0 && overrideBps > 0) {
+    return overrideBps;
+  }
+  const connection = navigator.connection;
+  if (connection?.downlink && connection.downlink > 0) {
+    const bps = connection.downlink * 1e6;
+    return Math.round(bps * 0.85);
+  }
+  return HLS_DEFAULT_ESTIMATE;
+}
 var HLS_ERROR_TYPES = {
   NETWORK_ERROR: "networkError",
   MEDIA_ERROR: "mediaError",
@@ -113,6 +125,14 @@ function setupHlsEventHandlers(hls, api, callbacks) {
     });
     callbacks.onLevelSwitched?.(data.level);
   });
+  let lastBandwidthUpdate = 0;
+  addHandler("hlsFragLoaded", () => {
+    const now = Date.now();
+    if (now - lastBandwidthUpdate >= 2e3 && hls.bandwidthEstimate) {
+      lastBandwidthUpdate = now;
+      api.setState("bandwidth", Math.round(hls.bandwidthEstimate));
+    }
+  });
   addHandler("hlsFragBuffered", () => {
     api.setState("buffering", false);
     callbacks.onBufferUpdate?.();
@@ -355,6 +375,7 @@ var DEFAULT_CONFIG$4 = {
   maxMaxBufferLength: 600,
   backBufferLength: 30,
   enableWorker: true,
+  capLevelToPlayerSize: true,
   // Error recovery settings
   maxNetworkRetries: 3,
   maxMediaRetries: 2,
@@ -424,11 +445,13 @@ function createHLSPlugin(config) {
     startPosition: mergedConfig.startPosition,
     startLevel: -1,
     // Auto quality selection (ABR)
+    abrEwmaDefaultEstimate: getInitialBandwidthEstimate(mergedConfig.initialBandwidthEstimate),
     lowLatencyMode: mergedConfig.lowLatencyMode,
     maxBufferLength: mergedConfig.maxBufferLength,
     maxMaxBufferLength: mergedConfig.maxMaxBufferLength,
     backBufferLength: mergedConfig.backBufferLength,
     enableWorker: mergedConfig.enableWorker,
+    capLevelToPlayerSize: mergedConfig.capLevelToPlayerSize,
     // Minimize hls.js internal retries - we handle retries ourselves
     fragLoadingMaxRetry: 1,
     manifestLoadingMaxRetry: 1,
@@ -699,7 +722,10 @@ function createHLSPlugin(config) {
       currentSrc = src;
       api.setState("playbackState", "loading");
       api.setState("buffering", true);
-      if (isHlsJsSupported()) {
+      if (api.getState("airplayActive") && supportsNativeHLS()) {
+        api.logger.info("Using native HLS (AirPlay active)");
+        await loadNative(src);
+      } else if (isHlsJsSupported()) {
         api.logger.info("Using hls.js for HLS playback");
         await loadWithHlsJs(src);
       } else if (supportsNativeHLS()) {
@@ -3241,6 +3267,37 @@ var CaptionsButton = class {
     this.el.remove();
   }
 };
+var ICON_SVG = `<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M5 12.55a11 11 0 0 1 14.08 0"/><path d="M1.42 9a16 16 0 0 1 21.16 0"/><path d="M8.53 16.11a6 6 0 0 1 6.95 0"/><line x1="12" y1="20" x2="12.01" y2="20"/><line x1="2" y1="2" x2="22" y2="22" stroke="currentColor" stroke-width="2"/></svg>`;
+var BandwidthIndicator = class {
+  constructor(api) {
+    this.api = api;
+    this.el = createElement("div", { className: "sp-bandwidth-indicator" });
+    this.el.innerHTML = ICON_SVG;
+    this.el.setAttribute("aria-label", "Bandwidth is limiting video quality");
+    this.el.setAttribute("title", "Bandwidth is limiting video quality");
+    this.el.style.display = "none";
+  }
+  render() {
+    return this.el;
+  }
+  update() {
+    const bandwidth = this.api.getState("bandwidth");
+    const qualities = this.api.getState("qualities");
+    if (!bandwidth || !qualities || qualities.length === 0) {
+      this.el.style.display = "none";
+      return;
+    }
+    const highestBitrate = Math.max(...qualities.map((q) => q.bitrate));
+    if (highestBitrate > 0 && bandwidth < highestBitrate) {
+      this.el.style.display = "";
+    } else {
+      this.el.style.display = "none";
+    }
+  }
+  destroy() {
+    this.el.remove();
+  }
+};
 var DEFAULT_LAYOUT = [
   "play",
   "skip-backward",
@@ -3248,6 +3305,7 @@ var DEFAULT_LAYOUT = [
   "volume",
   "time",
   "live-indicator",
+  "bandwidth-indicator",
   "spacer",
   "settings",
   "captions",
@@ -3288,6 +3346,8 @@ function uiPlugin(config = {}) {
         return new TimeDisplay(api);
       case "live-indicator":
         return new LiveIndicator(api);
+      case "bandwidth-indicator":
+        return new BandwidthIndicator(api);
       case "quality":
         return new QualityMenu(api);
       case "settings":
@@ -4875,7 +4935,9 @@ var DEFAULT_CONFIG$1 = {
   persist: false,
   persistKey: "scarlett-playlist",
   shuffle: false,
-  repeat: "none"
+  repeat: "none",
+  autoLoad: true,
+  advanceDelay: 0
 };
 function generateId() {
   return `track-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
@@ -4892,7 +4954,10 @@ function createPlaylistPlugin(config) {
   const mergedConfig = { ...DEFAULT_CONFIG$1, ...config };
   let api = null;
   let tracks = mergedConfig.tracks || [];
-  let currentIndex = -1;
+  let currentIndex = mergedConfig.initialIndex ?? -1;
+  if (currentIndex < -1 || currentIndex >= tracks.length) {
+    currentIndex = -1;
+  }
   let shuffle = mergedConfig.shuffle || false;
   let repeat = mergedConfig.repeat || "none";
   let shuffleOrder = [];
@@ -5019,6 +5084,9 @@ function createPlaylistPlugin(config) {
     }
     api?.setState("mediaType", track.type || "audio");
     emitChange();
+    if (mergedConfig.autoLoad !== false && track.src) {
+      api?.emit("media:load-request", { src: track.src, autoplay: true });
+    }
   };
   const plugin = {
     id: "playlist",
@@ -5033,12 +5101,20 @@ function createPlaylistPlugin(config) {
       if (shuffle && tracks.length > 0) {
         generateShuffleOrder();
       }
+      let advanceTimeout = null;
       const unsubEnded = api.on("playback:ended", () => {
         if (!mergedConfig.autoAdvance) return;
         const nextIdx = getNextIndex();
         if (nextIdx >= 0) {
-          api?.logger.debug("Auto-advancing to next track", { nextIdx });
-          setCurrentTrack(nextIdx);
+          const advance = () => {
+            api?.logger.debug("Auto-advancing to next track", { nextIdx });
+            setCurrentTrack(nextIdx);
+          };
+          if (mergedConfig.advanceDelay) {
+            advanceTimeout = setTimeout(advance, mergedConfig.advanceDelay);
+          } else {
+            advance();
+          }
         } else {
           api?.logger.info("Playlist ended");
           api?.emit("playlist:ended", void 0);
@@ -5046,6 +5122,10 @@ function createPlaylistPlugin(config) {
       });
       api.onDestroy(() => {
         unsubEnded();
+        if (advanceTimeout) {
+          clearTimeout(advanceTimeout);
+          advanceTimeout = null;
+        }
         persistPlaylist();
       });
     },
@@ -5491,6 +5571,336 @@ function createMediaSessionPlugin(config) {
   };
   return plugin;
 }
+var POSITIONS = ["top-left", "top-right", "bottom-left", "bottom-right", "center"];
+var POSITION_STYLES = {
+  "top-left": "top:10px;left:10px;",
+  "top-right": "top:10px;right:10px;",
+  "bottom-left": "bottom:40px;left:10px;",
+  "bottom-right": "bottom:40px;right:10px;",
+  "center": "top:50%;left:50%;transform:translate(-50%,-50%);"
+};
+function createWatermarkPlugin(config = {}) {
+  let api = null;
+  let element = null;
+  let dynamicTimer = null;
+  let showDelayTimer = null;
+  let currentPosition = config.position || "bottom-right";
+  const opacity = config.opacity ?? 0.5;
+  const fontSize = config.fontSize ?? 14;
+  const dynamic = config.dynamic ?? false;
+  const dynamicInterval = config.dynamicInterval ?? 1e4;
+  const showDelay = config.showDelay ?? 0;
+  const createElement2 = () => {
+    const el = document.createElement("div");
+    el.className = "sp-watermark sp-watermark--hidden";
+    el.style.cssText = `position:absolute;z-index:10;pointer-events:none;opacity:${opacity};font-size:${fontSize}px;color:#fff;text-shadow:0 1px 2px rgba(0,0,0,0.6);font-family:sans-serif;transition:all 0.5s ease;${POSITION_STYLES[currentPosition]}`;
+    el.setAttribute("data-position", currentPosition);
+    updateContent(el);
+    return el;
+  };
+  const updateContent = (el, imageUrl, text) => {
+    const img = imageUrl || config.imageUrl;
+    const txt = text || config.text;
+    el.innerHTML = "";
+    if (img) {
+      const imgEl = document.createElement("img");
+      imgEl.src = img;
+      imgEl.style.cssText = `max-height:${fontSize * 2}px;opacity:inherit;display:block;`;
+      imgEl.alt = "";
+      el.appendChild(imgEl);
+    } else if (txt) {
+      el.textContent = txt;
+    }
+  };
+  const setPosition = (position) => {
+    if (!element) return;
+    currentPosition = position;
+    element.style.top = "";
+    element.style.right = "";
+    element.style.bottom = "";
+    element.style.left = "";
+    element.style.transform = "";
+    const styles2 = POSITION_STYLES[position];
+    styles2.split(";").filter(Boolean).forEach((rule) => {
+      const colonIdx = rule.indexOf(":");
+      if (colonIdx === -1) return;
+      const prop = rule.slice(0, colonIdx).trim();
+      const val = rule.slice(colonIdx + 1).trim();
+      if (prop && val) {
+        element.style.setProperty(prop, val);
+      }
+    });
+    element.setAttribute("data-position", position);
+    const isVisible = element.classList.contains("sp-watermark--visible");
+    const visClass = isVisible ? " sp-watermark--visible" : " sp-watermark--hidden";
+    element.className = `sp-watermark sp-watermark--${position}${visClass}${dynamic ? " sp-watermark--dynamic" : ""}`;
+  };
+  const randomizePosition = () => {
+    const available = POSITIONS.filter((p) => p !== currentPosition);
+    const next = available[Math.floor(Math.random() * available.length)];
+    setPosition(next);
+  };
+  const show = () => {
+    if (!element) return;
+    element.classList.remove("sp-watermark--hidden");
+    element.classList.add("sp-watermark--visible");
+  };
+  const hide = () => {
+    if (!element) return;
+    element.classList.remove("sp-watermark--visible");
+    element.classList.add("sp-watermark--hidden");
+  };
+  const startDynamic = () => {
+    if (!dynamic || dynamicTimer) return;
+    dynamicTimer = setInterval(randomizePosition, dynamicInterval);
+  };
+  const stopDynamic = () => {
+    if (dynamicTimer) {
+      clearInterval(dynamicTimer);
+      dynamicTimer = null;
+    }
+  };
+  const cleanup = () => {
+    stopDynamic();
+    if (showDelayTimer) {
+      clearTimeout(showDelayTimer);
+      showDelayTimer = null;
+    }
+    if (element?.parentNode) {
+      element.parentNode.removeChild(element);
+    }
+    element = null;
+  };
+  return {
+    id: "watermark",
+    name: "Watermark",
+    version: "1.0.0",
+    type: "feature",
+    description: "Anti-piracy watermark overlay with text/image support and dynamic repositioning",
+    init(pluginApi) {
+      api = pluginApi;
+      api.logger.debug("Watermark plugin initialized");
+      element = createElement2();
+      api.container.appendChild(element);
+      const unsubPlay = api.on("playback:play", () => {
+        if (showDelay > 0) {
+          showDelayTimer = setTimeout(() => {
+            show();
+            startDynamic();
+          }, showDelay);
+        } else {
+          show();
+          startDynamic();
+        }
+      });
+      const unsubPause = api.on("playback:pause", () => {
+        hide();
+        stopDynamic();
+        if (showDelayTimer) {
+          clearTimeout(showDelayTimer);
+          showDelayTimer = null;
+        }
+      });
+      const unsubEnded = api.on("playback:ended", () => {
+        hide();
+        stopDynamic();
+      });
+      const unsubChange = api.on("playlist:change", ({ track }) => {
+        if (!element || !track) return;
+        const metadata = track.metadata;
+        if (metadata) {
+          const watermarkUrl = metadata.watermarkUrl;
+          const watermarkText = metadata.watermarkText;
+          if (watermarkUrl || watermarkText) {
+            updateContent(element, watermarkUrl, watermarkText);
+          }
+        }
+      });
+      api.onDestroy(() => {
+        unsubPlay();
+        unsubPause();
+        unsubEnded();
+        unsubChange();
+        cleanup();
+      });
+    },
+    destroy() {
+      api?.logger.debug("Watermark plugin destroyed");
+      cleanup();
+      api = null;
+    },
+    setText(text) {
+      if (element) updateContent(element, void 0, text);
+    },
+    setImage(imageUrl) {
+      if (element) updateContent(element, imageUrl);
+    },
+    setPosition,
+    setOpacity(value) {
+      if (element) element.style.opacity = String(Math.max(0, Math.min(1, value)));
+    },
+    show,
+    hide,
+    getConfig() {
+      return { ...config, position: currentPosition, opacity: element ? parseFloat(element.style.opacity) || opacity : opacity };
+    }
+  };
+}
+function createCaptionsPlugin(config = {}) {
+  let api = null;
+  let video = null;
+  let addedTrackElements = [];
+  const extractFromHLS = config.extractFromHLS !== false;
+  const autoSelect = config.autoSelect ?? false;
+  const defaultLanguage = config.defaultLanguage ?? "en";
+  const getVideo2 = () => {
+    if (video) return video;
+    video = api?.container.querySelector("video") ?? null;
+    return video;
+  };
+  const cleanupTracks = () => {
+    for (const trackEl of addedTrackElements) {
+      trackEl.parentNode?.removeChild(trackEl);
+    }
+    addedTrackElements = [];
+    api?.setState("textTracks", []);
+    api?.setState("currentTextTrack", null);
+  };
+  const addTrackElement = (source) => {
+    const videoEl = getVideo2();
+    if (!videoEl) throw new Error("No video element");
+    const trackEl = document.createElement("track");
+    trackEl.kind = source.kind || "subtitles";
+    trackEl.label = source.label;
+    trackEl.srclang = source.language;
+    trackEl.src = source.src;
+    trackEl.default = false;
+    videoEl.appendChild(trackEl);
+    addedTrackElements.push(trackEl);
+    if (trackEl.track) {
+      trackEl.track.mode = "disabled";
+    }
+    return trackEl;
+  };
+  const syncTracksToState = () => {
+    const videoEl = getVideo2();
+    if (!videoEl) return;
+    const tracks = [];
+    let currentTrack = null;
+    for (let i = 0; i < videoEl.textTracks.length; i++) {
+      const track = videoEl.textTracks[i];
+      if (track.kind !== "subtitles" && track.kind !== "captions") continue;
+      const scarlettTrack = {
+        id: `track-${i}`,
+        label: track.label || `Track ${i + 1}`,
+        language: track.language || "",
+        kind: track.kind,
+        active: track.mode === "showing"
+      };
+      tracks.push(scarlettTrack);
+      if (track.mode === "showing") {
+        currentTrack = scarlettTrack;
+      }
+    }
+    api?.setState("textTracks", tracks);
+    api?.setState("currentTextTrack", currentTrack);
+  };
+  const selectTrack = (trackId) => {
+    const videoEl = getVideo2();
+    if (!videoEl) return;
+    for (let i = 0; i < videoEl.textTracks.length; i++) {
+      const track = videoEl.textTracks[i];
+      if (track.kind !== "subtitles" && track.kind !== "captions") continue;
+      const id = `track-${i}`;
+      if (trackId && id === trackId) {
+        track.mode = "showing";
+      } else {
+        track.mode = "disabled";
+      }
+    }
+    syncTracksToState();
+  };
+  const extractHlsSubtitles = () => {
+    if (!extractFromHLS || !api) return;
+    const hlsPlugin = api.getPlugin("hls-provider");
+    if (!hlsPlugin || hlsPlugin.isNativeHLS()) return;
+    const hlsInstance = hlsPlugin.getHlsInstance();
+    if (!hlsInstance?.subtitleTracks?.length) return;
+    api.logger.debug("Extracting HLS subtitle tracks", {
+      count: hlsInstance.subtitleTracks.length
+    });
+    for (const hlsTrack of hlsInstance.subtitleTracks) {
+      addTrackElement({
+        language: hlsTrack.lang || "unknown",
+        label: hlsTrack.name || `Subtitle ${hlsTrack.id}`,
+        src: hlsTrack.url,
+        kind: "subtitles"
+      });
+    }
+    syncTracksToState();
+    if (autoSelect) {
+      autoSelectTrack();
+    }
+  };
+  const autoSelectTrack = () => {
+    const tracks = api?.getState("textTracks") || [];
+    const match = tracks.find((t) => t.language === defaultLanguage);
+    if (match) {
+      selectTrack(match.id);
+      api?.logger.debug("Auto-selected caption track", { language: defaultLanguage, id: match.id });
+    }
+  };
+  const initSources = () => {
+    if (!config.sources?.length) return;
+    for (const source of config.sources) {
+      addTrackElement(source);
+    }
+    syncTracksToState();
+    if (autoSelect) {
+      autoSelectTrack();
+    }
+  };
+  return {
+    id: "captions",
+    name: "Captions",
+    version: "1.0.0",
+    type: "feature",
+    description: "WebVTT subtitles and closed captions with HLS extraction",
+    init(pluginApi) {
+      api = pluginApi;
+      api.logger.debug("Captions plugin initialized");
+      api.setState("textTracks", []);
+      api.setState("currentTextTrack", null);
+      const unsubTrackText = api.on("track:text", ({ trackId }) => {
+        selectTrack(trackId);
+      });
+      const unsubLoaded = api.on("media:loaded", () => {
+        video = null;
+        cleanupTracks();
+        initSources();
+        if (extractFromHLS) {
+          setTimeout(extractHlsSubtitles, 500);
+        }
+      });
+      const unsubLoadRequest = api.on("media:load-request", () => {
+        video = null;
+        cleanupTracks();
+      });
+      api.onDestroy(() => {
+        unsubTrackText();
+        unsubLoaded();
+        unsubLoadRequest();
+        cleanupTracks();
+      });
+    },
+    destroy() {
+      api?.logger.debug("Captions plugin destroyed");
+      cleanupTracks();
+      video = null;
+      api = null;
+    }
+  };
+}
 class Signal {
   constructor(initialValue) {
     this.subscribers = /* @__PURE__ */ new Set();
@@ -7030,6 +7440,13 @@ class ScarlettPlayer {
         await this.pluginManager.initPlugin(id);
       }
     }
+    this.eventBus.on("media:load-request", async ({ src, autoplay }) => {
+      if (this.stateManager.getValue("chromecastActive")) return;
+      await this.load(src);
+      if (autoplay !== false) {
+        await this.play();
+      }
+    });
     if (this.initialSrc) {
       await this.load(this.initialSrc);
     }
@@ -7857,6 +8274,12 @@ async function createEmbedPlayer(container, config, pluginCreators2, availableTy
         artwork: config.artwork || config.poster || config.playlist?.[0]?.artwork
       }));
     }
+    if (pluginCreators2.watermark && config.watermark) {
+      plugins.push(pluginCreators2.watermark(config.watermark));
+    }
+    if (pluginCreators2.captions) {
+      plugins.push(pluginCreators2.captions(config.captions || {}));
+    }
     if (pluginCreators2.analytics && config.analytics?.beaconUrl) {
       plugins.push(pluginCreators2.analytics({
         beaconUrl: config.analytics.beaconUrl,
@@ -7974,7 +8397,7 @@ function setupAutoInit(pluginCreators2, availableTypes) {
     }
   }
 }
-const VERSION = "0.3.0";
+const VERSION = "0.5.3";
 const AVAILABLE_TYPES = ["video", "audio", "audio-mini"];
 const pluginCreators = {
   hls: createHLSPlugin,
@@ -7982,7 +8405,9 @@ const pluginCreators = {
   audioUI: createAudioUIPlugin,
   analytics: createAnalyticsPlugin,
   playlist: createPlaylistPlugin,
-  mediaSession: createMediaSessionPlugin
+  mediaSession: createMediaSessionPlugin,
+  watermark: createWatermarkPlugin,
+  captions: createCaptionsPlugin
 };
 const ScarlettPlayerAPI = createScarlettPlayerAPI(
   pluginCreators,