@scarlett-player/hls 0.1.0 → 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Hackney Enterprises Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,65 @@
+# @scarlett-player/hls
+
+HLS playback plugin for Scarlett Player. Uses hls.js with native Safari fallback.
+
+## Installation
+
+```bash
+npm install @scarlett-player/core @scarlett-player/hls
+```
+
+## Usage
+
+```typescript
+import { ScarlettPlayer } from '@scarlett-player/core';
+import { createHLSPlugin } from '@scarlett-player/hls';
+
+const player = new ScarlettPlayer({
+  container: document.getElementById('player'),
+  plugins: [createHLSPlugin()],
+});
+
+await player.init();
+await player.load('https://example.com/video.m3u8');
+```
+
+## Features
+
+- Adaptive bitrate streaming
+- Quality level selection
+- Live stream support with DVR
+- Native Safari HLS fallback
+- Automatic hls.js loading
+
+## Configuration
+
+```typescript
+createHLSPlugin({
+  // hls.js config options
+  hlsConfig: {
+    maxBufferLength: 30,
+    maxMaxBufferLength: 600,
+  },
+  // Prefer native HLS when available (Safari)
+  preferNativeHLS: false,
+});
+```
+
+## Quality Selection
+
+```typescript
+// Get available qualities
+const qualities = player.getQualities();
+// [{ index: 0, height: 1080, bitrate: 5000000 }, ...]
+
+// Set quality (use -1 for auto)
+player.setQuality(0);  // Highest quality
+player.setQuality(-1); // Auto/ABR
+
+// Get current quality
+const current = player.getCurrentQuality();
+```
+
+## License
+
+MIT

package/dist/chunk-CBBDW7UR.js

@@ -0,0 +1,263 @@
+// 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;
+  };
+}
+
+export {
+  mapLevels,
+  setupHlsEventHandlers,
+  setupVideoEventHandlers
+};

package/dist/index.cjs

@@ -390,6 +390,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;
   };
@@ -648,8 +652,8 @@ function createHLSPlugin(config) {
           isAutoQuality = false;
           const levelIndex = parseInt(quality.replace("level-", ""), 10);
           if (!isNaN(levelIndex) && levelIndex >= 0 && levelIndex < hls.levels.length) {
-            hls.currentLevel = levelIndex;
-            api?.logger.debug(`Quality: set to level ${levelIndex}`);
+            hls.nextLevel = levelIndex;
+            api?.logger.debug(`Quality: queued switch to level ${levelIndex}`);
           }
         }
       });

package/dist/index.d.cts

@@ -1,102 +1,6 @@
-import { Plugin } from '@scarlett-player/core';
-
-/**
- * HLS Plugin Types
- */
-
-/** HLS plugin configuration options */
-interface HLSPluginConfig {
-    /** Enable debug logging */
-    debug?: boolean;
-    /** Auto start loading when source is set */
-    autoStartLoad?: boolean;
-    /** Start position in seconds (-1 for default) */
-    startPosition?: number;
-    /** Enable low latency mode for live streams */
-    lowLatencyMode?: boolean;
-    /** Max buffer length in seconds */
-    maxBufferLength?: number;
-    /** Max max buffer length in seconds */
-    maxMaxBufferLength?: number;
-    /** Back buffer length in seconds for DVR */
-    backBufferLength?: number;
-    /** Enable worker for hls.js (better performance) */
-    enableWorker?: boolean;
-    /** Max network error retries before giving up (default: 3) */
-    maxNetworkRetries?: number;
-    /** Max media error retries before giving up (default: 2) */
-    maxMediaRetries?: number;
-    /** Base retry delay in milliseconds (default: 1000) */
-    retryDelayMs?: number;
-    /** Exponential backoff multiplier (default: 2) */
-    retryBackoffFactor?: number;
-    /** Index signature for PluginConfig compatibility */
-    [key: string]: unknown;
-}
-/** Quality level information */
-interface HLSQualityLevel {
-    /** Level index in hls.js */
-    index: number;
-    /** Video width */
-    width: number;
-    /** Video height */
-    height: number;
-    /** Bitrate in bits per second */
-    bitrate: number;
-    /** Human-readable label (e.g., "1080p") */
-    label: string;
-    /** Codec info */
-    codec?: string;
-}
-/** HLS error types */
-type HLSErrorType = 'network' | 'media' | 'mux' | 'other';
-/** HLS error details */
-interface HLSError {
-    type: HLSErrorType;
-    details: string;
-    fatal: boolean;
-    url?: string;
-    reason?: string;
-    response?: {
-        code: number;
-        text: string;
-    };
-}
-/** Live stream info */
-interface HLSLiveInfo {
-    /** Whether stream is live */
-    isLive: boolean;
-    /** Edge latency in seconds */
-    latency: number;
-    /** Target latency for low latency mode */
-    targetLatency: number;
-    /** Drift from live edge */
-    drift: number;
-}
-/** HLS Plugin interface extending base Plugin */
-interface IHLSPlugin extends Plugin<HLSPluginConfig> {
-    readonly id: 'hls-provider';
-    /** Check if this provider can play a source */
-    canPlay(src: string): boolean;
-    /** Load and play a source */
-    loadSource(src: string): Promise<void>;
-    /** Get current quality level index (-1 = auto) */
-    getCurrentLevel(): number;
-    /** Set quality level (-1 for auto) */
-    setLevel(index: number): void;
-    /** Get all available quality levels */
-    getLevels(): HLSQualityLevel[];
-    /** Get the raw hls.js instance (for advanced use) */
-    getHlsInstance(): unknown | null;
-    /** Check if using native HLS (Safari) */
-    isNativeHLS(): boolean;
-    /** Get live stream info */
-    getLiveInfo(): HLSLiveInfo | null;
-    /** Switch from hls.js to native HLS (for AirPlay) */
-    switchToNative(): Promise<void>;
-    /** Switch from native HLS back to hls.js */
-    switchToHlsJs(): Promise<void>;
-}
+import { H as HLSPluginConfig, I as IHLSPlugin } from './types-Co8zOXVb.cjs';
+export { b as HLSError, c as HLSLiveInfo, a as HLSQualityLevel } from './types-Co8zOXVb.cjs';
+import '@scarlett-player/core';
 
 /**
  * HLS Provider Plugin for Scarlett Player
@@ -130,4 +34,4 @@ interface IHLSPlugin extends Plugin<HLSPluginConfig> {
  */
 declare function createHLSPlugin(config?: Partial<HLSPluginConfig>): IHLSPlugin;
 
-export { type HLSError, type HLSLiveInfo, type HLSPluginConfig, type HLSQualityLevel, type IHLSPlugin, createHLSPlugin, createHLSPlugin as default };
+export { HLSPluginConfig, IHLSPlugin, createHLSPlugin, createHLSPlugin as default };

package/dist/index.d.ts

@@ -1,102 +1,6 @@
-import { Plugin } from '@scarlett-player/core';
-
-/**
- * HLS Plugin Types
- */
-
-/** HLS plugin configuration options */
-interface HLSPluginConfig {
-    /** Enable debug logging */
-    debug?: boolean;
-    /** Auto start loading when source is set */
-    autoStartLoad?: boolean;
-    /** Start position in seconds (-1 for default) */
-    startPosition?: number;
-    /** Enable low latency mode for live streams */
-    lowLatencyMode?: boolean;
-    /** Max buffer length in seconds */
-    maxBufferLength?: number;
-    /** Max max buffer length in seconds */
-    maxMaxBufferLength?: number;
-    /** Back buffer length in seconds for DVR */
-    backBufferLength?: number;
-    /** Enable worker for hls.js (better performance) */
-    enableWorker?: boolean;
-    /** Max network error retries before giving up (default: 3) */
-    maxNetworkRetries?: number;
-    /** Max media error retries before giving up (default: 2) */
-    maxMediaRetries?: number;
-    /** Base retry delay in milliseconds (default: 1000) */
-    retryDelayMs?: number;
-    /** Exponential backoff multiplier (default: 2) */
-    retryBackoffFactor?: number;
-    /** Index signature for PluginConfig compatibility */
-    [key: string]: unknown;
-}
-/** Quality level information */
-interface HLSQualityLevel {
-    /** Level index in hls.js */
-    index: number;
-    /** Video width */
-    width: number;
-    /** Video height */
-    height: number;
-    /** Bitrate in bits per second */
-    bitrate: number;
-    /** Human-readable label (e.g., "1080p") */
-    label: string;
-    /** Codec info */
-    codec?: string;
-}
-/** HLS error types */
-type HLSErrorType = 'network' | 'media' | 'mux' | 'other';
-/** HLS error details */
-interface HLSError {
-    type: HLSErrorType;
-    details: string;
-    fatal: boolean;
-    url?: string;
-    reason?: string;
-    response?: {
-        code: number;
-        text: string;
-    };
-}
-/** Live stream info */
-interface HLSLiveInfo {
-    /** Whether stream is live */
-    isLive: boolean;
-    /** Edge latency in seconds */
-    latency: number;
-    /** Target latency for low latency mode */
-    targetLatency: number;
-    /** Drift from live edge */
-    drift: number;
-}
-/** HLS Plugin interface extending base Plugin */
-interface IHLSPlugin extends Plugin<HLSPluginConfig> {
-    readonly id: 'hls-provider';
-    /** Check if this provider can play a source */
-    canPlay(src: string): boolean;
-    /** Load and play a source */
-    loadSource(src: string): Promise<void>;
-    /** Get current quality level index (-1 = auto) */
-    getCurrentLevel(): number;
-    /** Set quality level (-1 for auto) */
-    setLevel(index: number): void;
-    /** Get all available quality levels */
-    getLevels(): HLSQualityLevel[];
-    /** Get the raw hls.js instance (for advanced use) */
-    getHlsInstance(): unknown | null;
-    /** Check if using native HLS (Safari) */
-    isNativeHLS(): boolean;
-    /** Get live stream info */
-    getLiveInfo(): HLSLiveInfo | null;
-    /** Switch from hls.js to native HLS (for AirPlay) */
-    switchToNative(): Promise<void>;
-    /** Switch from native HLS back to hls.js */
-    switchToHlsJs(): Promise<void>;
-}
+import { H as HLSPluginConfig, I as IHLSPlugin } from './types-Co8zOXVb.js';
+export { b as HLSError, c as HLSLiveInfo, a as HLSQualityLevel } from './types-Co8zOXVb.js';
+import '@scarlett-player/core';
 
 /**
  * HLS Provider Plugin for Scarlett Player
@@ -130,4 +34,4 @@ interface IHLSPlugin extends Plugin<HLSPluginConfig> {
  */
 declare function createHLSPlugin(config?: Partial<HLSPluginConfig>): IHLSPlugin;
 
-export { type HLSError, type HLSLiveInfo, type HLSPluginConfig, type HLSQualityLevel, type IHLSPlugin, createHLSPlugin, createHLSPlugin as default };
+export { HLSPluginConfig, IHLSPlugin, createHLSPlugin, createHLSPlugin as default };