@scarlett-player/hls 1.1.1 → 1.4.0

package/dist/chunk-L73PRXS4.js

@@ -1,337 +0,0 @@
-// src/quality.ts
-function formatLevel(level) {
-  if (level.name) {
-    return level.name;
-  }
-  if (level.height) {
-    const standardLabels = {
-      2160: "4K",
-      1440: "1440p",
-      1080: "1080p",
-      720: "720p",
-      480: "480p",
-      360: "360p",
-      240: "240p",
-      144: "144p"
-    };
-    const closest = Object.keys(standardLabels).map(Number).sort((a, b) => Math.abs(a - level.height) - Math.abs(b - level.height))[0];
-    if (Math.abs(closest - level.height) <= 20) {
-      return standardLabels[closest];
-    }
-    return `${level.height}p`;
-  }
-  if (level.bitrate) {
-    return formatBitrate(level.bitrate);
-  }
-  return "Unknown";
-}
-function formatBitrate(bitrate) {
-  if (bitrate >= 1e6) {
-    return `${(bitrate / 1e6).toFixed(1)} Mbps`;
-  }
-  if (bitrate >= 1e3) {
-    return `${Math.round(bitrate / 1e3)} Kbps`;
-  }
-  return `${bitrate} bps`;
-}
-function mapLevels(levels, _currentLevel) {
-  return levels.map((level, index) => ({
-    index,
-    width: level.width || 0,
-    height: level.height || 0,
-    bitrate: level.bitrate || 0,
-    label: formatLevel(level),
-    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;
-}
-
-// src/event-map.ts
-var HLS_ERROR_TYPES = {
-  NETWORK_ERROR: "networkError",
-  MEDIA_ERROR: "mediaError",
-  KEY_SYSTEM_ERROR: "keySystemError",
-  MUX_ERROR: "muxError",
-  OTHER_ERROR: "otherError"
-};
-function mapErrorType(hlsType) {
-  switch (hlsType) {
-    case HLS_ERROR_TYPES.NETWORK_ERROR:
-      return "network";
-    case HLS_ERROR_TYPES.MEDIA_ERROR:
-      return "media";
-    case HLS_ERROR_TYPES.MUX_ERROR:
-      return "mux";
-    default:
-      return "other";
-  }
-}
-function parseHlsError(data) {
-  return {
-    type: mapErrorType(data.type),
-    details: data.details || "Unknown error",
-    fatal: data.fatal || false,
-    url: data.url,
-    reason: data.reason,
-    response: data.response
-  };
-}
-function setupHlsEventHandlers(hls, api, callbacks) {
-  const handlers = [];
-  const addHandler = (event, handler) => {
-    hls.on(event, handler);
-    handlers.push({ event, handler });
-  };
-  addHandler("hlsManifestParsed", (_event, data) => {
-    api.logger.debug("HLS manifest parsed", { levels: data.levels.length });
-    const levels = data.levels.map((level, index) => ({
-      id: `level-${index}`,
-      label: formatLevel(level),
-      width: level.width,
-      height: level.height,
-      bitrate: level.bitrate,
-      active: index === hls.currentLevel
-    }));
-    api.setState("qualities", levels);
-    api.emit("quality:levels", {
-      levels: levels.map((l) => ({ id: l.id, label: l.label }))
-    });
-    callbacks.onManifestParsed?.(data.levels);
-  });
-  addHandler("hlsLevelSwitched", (_event, data) => {
-    const level = hls.levels[data.level];
-    const isAuto = callbacks.getIsAutoQuality?.() ?? hls.autoLevelEnabled;
-    api.logger.debug("HLS level switched", { level: data.level, height: level?.height, auto: isAuto });
-    if (level) {
-      const label = isAuto ? `Auto (${formatLevel(level)})` : formatLevel(level);
-      api.setState("currentQuality", {
-        id: isAuto ? "auto" : `level-${data.level}`,
-        label,
-        width: level.width,
-        height: level.height,
-        bitrate: level.bitrate,
-        active: true
-      });
-    }
-    api.emit("quality:change", {
-      quality: level ? formatLevel(level) : "auto",
-      auto: isAuto
-    });
-    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));
-    }
-    callbacks.onFragLoaded?.();
-  });
-  addHandler("hlsFragBuffered", () => {
-    api.setState("buffering", false);
-    callbacks.onBufferUpdate?.();
-  });
-  addHandler("hlsFragLoading", () => {
-    api.setState("buffering", true);
-  });
-  addHandler("hlsLevelLoaded", (_event, data) => {
-    if (data.details?.live !== void 0) {
-      api.setState("live", data.details.live);
-      if (data.details.live) {
-        const video = hls.media;
-        if (video && video.seekable && video.seekable.length > 0) {
-          const start = video.seekable.start(0);
-          const end = video.seekable.end(video.seekable.length - 1);
-          api.setState("seekableRange", { start, end });
-          const threshold = (data.details.targetduration ?? 3) * 3;
-          const isAtLiveEdge = end - video.currentTime < threshold;
-          api.setState("liveEdge", isAtLiveEdge);
-          const latency = end - video.currentTime;
-          api.setState("liveLatency", Math.max(0, latency));
-        }
-      }
-      callbacks.onLiveUpdate?.();
-    }
-  });
-  addHandler("hlsError", (_event, data) => {
-    const error = parseHlsError(data);
-    const isBufferHoleSeek = !error.fatal && (error.details?.includes("bufferStalledError") || data.reason?.includes("buffer holes"));
-    if (isBufferHoleSeek) {
-      api.logger.debug(`HLS buffer recovery: ${error.reason || error.details}`, {
-        details: error.details,
-        reason: error.reason
-      });
-    } else if (error.fatal) {
-      api.logger.error(`HLS fatal error: ${error.details} (type=${error.type})`, {
-        type: error.type,
-        details: error.details,
-        url: error.url
-      });
-    } else {
-      api.logger.warn(`HLS error: ${error.details} (type=${error.type}, fatal=${error.fatal})`, {
-        type: error.type,
-        details: error.details,
-        fatal: error.fatal,
-        url: error.url
-      });
-    }
-    callbacks.onError?.(error);
-  });
-  return () => {
-    for (const { event, handler } of handlers) {
-      hls.off(event, handler);
-    }
-    handlers.length = 0;
-  };
-}
-function setupVideoEventHandlers(video, api) {
-  const handlers = [];
-  const addHandler = (event, handler) => {
-    video.addEventListener(event, handler);
-    handlers.push({ event, handler });
-  };
-  addHandler("play", () => {
-    api.setState("paused", false);
-  });
-  addHandler("playing", () => {
-    api.setState("playing", true);
-    api.setState("paused", false);
-    api.setState("waiting", false);
-    api.setState("buffering", false);
-    api.setState("playbackState", "playing");
-  });
-  addHandler("pause", () => {
-    api.setState("playing", false);
-    api.setState("paused", true);
-    api.setState("playbackState", "paused");
-  });
-  addHandler("ended", () => {
-    api.setState("playing", false);
-    api.setState("ended", true);
-    api.setState("playbackState", "ended");
-    api.emit("playback:ended", void 0);
-  });
-  addHandler("timeupdate", () => {
-    api.setState("currentTime", video.currentTime);
-    api.emit("playback:timeupdate", { currentTime: video.currentTime });
-    const isLive = api.getState("live");
-    if (isLive && video.seekable && video.seekable.length > 0) {
-      const start = video.seekable.start(0);
-      const end = video.seekable.end(video.seekable.length - 1);
-      api.setState("seekableRange", { start, end });
-      const isAtLiveEdge = end - video.currentTime < 10;
-      api.setState("liveEdge", isAtLiveEdge);
-      api.setState("liveLatency", Math.max(0, end - video.currentTime));
-    }
-  });
-  addHandler("durationchange", () => {
-    api.setState("duration", video.duration || 0);
-    api.emit("media:loadedmetadata", { duration: video.duration || 0 });
-  });
-  addHandler("waiting", () => {
-    api.setState("waiting", true);
-    api.setState("buffering", true);
-    api.emit("media:waiting", void 0);
-  });
-  addHandler("canplay", () => {
-    api.setState("waiting", false);
-    api.setState("playbackState", "ready");
-    api.emit("media:canplay", void 0);
-  });
-  addHandler("canplaythrough", () => {
-    api.setState("buffering", false);
-    api.emit("media:canplaythrough", void 0);
-  });
-  addHandler("progress", () => {
-    if (video.buffered.length > 0) {
-      const bufferedEnd = video.buffered.end(video.buffered.length - 1);
-      const bufferedAmount = video.duration > 0 ? bufferedEnd / video.duration : 0;
-      api.setState("bufferedAmount", bufferedAmount);
-      api.setState("buffered", video.buffered);
-      api.emit("media:progress", { buffered: bufferedAmount });
-    }
-  });
-  addHandler("seeking", () => {
-    api.setState("seeking", true);
-  });
-  addHandler("seeked", () => {
-    api.setState("seeking", false);
-    api.emit("playback:seeked", { time: video.currentTime });
-  });
-  addHandler("volumechange", () => {
-    api.setState("volume", video.volume);
-    api.setState("muted", video.muted);
-    api.emit("volume:change", { volume: video.volume, muted: video.muted });
-  });
-  addHandler("ratechange", () => {
-    api.setState("playbackRate", video.playbackRate);
-    api.emit("playback:ratechange", { rate: video.playbackRate });
-  });
-  addHandler("loadedmetadata", () => {
-    api.setState("duration", video.duration);
-    api.setState("mediaType", video.videoWidth > 0 ? "video" : "audio");
-  });
-  addHandler("loadeddata", () => {
-    if (video.videoWidth > 0) {
-      api.setState("mediaType", "video");
-    }
-  });
-  addHandler("error", () => {
-    const error = video.error;
-    if (error) {
-      api.logger.error("Video element error", { code: error.code, message: error.message });
-      api.emit("media:error", { error: new Error(error.message || "Video playback error") });
-    }
-  });
-  addHandler("enterpictureinpicture", () => {
-    api.setState("pip", true);
-    api.logger.debug("PiP: entered (standard)");
-  });
-  addHandler("leavepictureinpicture", () => {
-    api.setState("pip", false);
-    api.logger.debug("PiP: exited (standard)");
-    if (!video.paused || api.getState("playing")) {
-      video.play().catch(() => {
-      });
-    }
-  });
-  const webkitVideo = video;
-  if ("webkitPresentationMode" in video) {
-    addHandler("webkitpresentationmodechanged", () => {
-      const mode = webkitVideo.webkitPresentationMode;
-      const isInPip = mode === "picture-in-picture";
-      api.setState("pip", isInPip);
-      api.logger.debug(`PiP: mode changed to ${mode} (webkit)`);
-      if (mode === "inline" && video.paused) {
-        video.play().catch(() => {
-        });
-      }
-    });
-  }
-  return () => {
-    for (const { event, handler } of handlers) {
-      video.removeEventListener(event, handler);
-    }
-    handlers.length = 0;
-  };
-}
-
-export {
-  formatLevel,
-  mapLevels,
-  getInitialBandwidthEstimate,
-  setupHlsEventHandlers,
-  setupVideoEventHandlers
-};