@scarlett-player/hls 0.1.2 → 0.2.0

package/dist/index.js

@@ -1,3 +1,9 @@
+import {
+  mapLevels,
+  setupHlsEventHandlers,
+  setupVideoEventHandlers
+} from "./chunk-CBBDW7UR.js";
+
 // src/hls-loader.ts
 var hlsConstructor = null;
 var loadingPromise = null;
@@ -50,264 +56,6 @@ function getHlsConstructor() {
   return hlsConstructor;
 }
 
-// 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
-  }));
-}
-
-// 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);
-  });
-  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);
-      callbacks.onLiveUpdate?.();
-    }
-  });
-  addHandler("hlsError", (_event, data) => {
-    const error = parseHlsError(data);
-    api.logger.warn("HLS error", { error });
-    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("playing", () => {
-    api.setState("playing", true);
-    api.setState("paused", 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 });
-  });
-  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("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;
-  };
-}
-
 // src/index.ts
 var DEFAULT_CONFIG = {
   debug: false,
@@ -353,6 +101,10 @@ function createHLSPlugin(config) {
     video.preload = "metadata";
     video.controls = false;
     video.playsInline = true;
+    const poster = api?.getState("poster");
+    if (poster) {
+      video.poster = poster;
+    }
     api?.container.appendChild(video);
     return video;
   };