@rixl/media-core 1.0.2 → 1.1.0

package/dist/lib/player-ui-actions.d.ts

@@ -1,10 +0,0 @@
-import { UUID } from "../types/uuid.js";
-interface PlayerUiActionTargets {
-  container?: HTMLDivElement | null;
-  video?: HTMLVideoElement | null;
-}
-export declare function showPlayerControls(playerId: UUID): void;
-export declare function hidePlayerControls(playerId: UUID): void;
-export declare function togglePlayerFullscreen(playerId: UUID, overrides?: PlayerUiActionTargets): Promise<void>;
-export declare function togglePlayerPictureInPicture(playerId: UUID, overrides?: PlayerUiActionTargets): Promise<void>;
-export {};

package/dist/lib/player-ui-actions.js

@@ -1,58 +0,0 @@
-import { isDocumentFullscreen } from "./fullscreen-utils.js";
-import { togglePictureInPicture } from "./pip-utils.js";
-import { controlsStore } from "../store/controls-store.js";
-import { playerContainerElementStore } from "../store/player-container-element-store.js";
-import { playerMediaElementStore } from "../store/player-media-element-store.js";
-import { playerStateStore } from "../store/player-store.js";
-
-// src/lib/player-ui-actions.ts
-function getPlayerUiTargets(playerId, overrides) {
-	return {
-		container: overrides?.container ?? playerContainerElementStore.get(playerId),
-		video: overrides?.video ?? playerMediaElementStore.get(playerId)
-	};
-}
-function shouldExitFullscreen(playerId) {
-	return playerStateStore.get(playerId).get().isFullscreen || isDocumentFullscreen();
-}
-async function exitPlayerFullscreen(playerId, video) {
-	try {
-		if (isDocumentFullscreen() && document.exitFullscreen) await document.exitFullscreen();
-		else if (video && typeof video.webkitExitFullscreen === "function") video.webkitExitFullscreen();
-		else return;
-		playerStateStore.setFullscreen(playerId, false);
-	} catch {}
-}
-async function enterPlayerFullscreen(playerId, container, video) {
-	try {
-		if (container?.requestFullscreen) await container.requestFullscreen();
-		else if (video?.requestFullscreen) await video.requestFullscreen();
-		else if (video && typeof video.webkitEnterFullscreen === "function") video.webkitEnterFullscreen();
-		else return;
-		playerStateStore.setFullscreen(playerId, true);
-	} catch {}
-}
-function showPlayerControls(playerId) {
-	controlsStore.setVisible(playerId, true);
-}
-function hidePlayerControls(playerId) {
-	controlsStore.hideControls(playerId);
-}
-async function togglePlayerFullscreen(playerId, overrides) {
-	const { container, video } = getPlayerUiTargets(playerId, overrides);
-	if (!container && !video) return;
-	if (shouldExitFullscreen(playerId)) {
-		await exitPlayerFullscreen(playerId, video);
-		return;
-	}
-	await enterPlayerFullscreen(playerId, container, video);
-}
-async function togglePlayerPictureInPicture(playerId, overrides) {
-	const { video } = getPlayerUiTargets(playerId, overrides);
-	if (!video) return;
-	const nextPictureInPictureState = !playerStateStore.get(playerId).get().isPictureInPicture;
-	await togglePictureInPicture(video);
-	playerStateStore.setPictureInPicture(playerId, nextPictureInPictureState);
-}
-
-export { hidePlayerControls, showPlayerControls, togglePlayerFullscreen, togglePlayerPictureInPicture };

package/dist/lib/progress-fraction.d.ts

@@ -1,11 +0,0 @@
-/**
- * Pure progress-fraction helper extracted from useProgressBar.
- *
- * Returns a value in [0, 1] representing how far through `duration`
- * `currentTime` is. Defensive against the common edge cases where
- * duration is zero, NaN, or Infinity (e.g. before metadata loads),
- * and against non-finite currentTime values. The previous inline
- * `video.currentTime / video.duration` formula produced NaN in
- * those cases, which leaked into React state.
- */
-export declare function computeProgressFraction(currentTime: number, duration: number): number;

package/dist/lib/progress-fraction.js

@@ -1,20 +0,0 @@
-// src/lib/progress-fraction.ts
-/**
-* Pure progress-fraction helper extracted from useProgressBar.
-*
-* Returns a value in [0, 1] representing how far through `duration`
-* `currentTime` is. Defensive against the common edge cases where
-* duration is zero, NaN, or Infinity (e.g. before metadata loads),
-* and against non-finite currentTime values. The previous inline
-* `video.currentTime / video.duration` formula produced NaN in
-* those cases, which leaked into React state.
-*/
-function computeProgressFraction(currentTime, duration) {
-	if (!Number.isFinite(duration) || duration <= 0) return 0;
-	if (!Number.isFinite(currentTime)) return 0;
-	if (currentTime <= 0) return 0;
-	if (currentTime >= duration) return 1;
-	return currentTime / duration;
-}
-
-export { computeProgressFraction };

package/dist/lib/progress-persist.d.ts

@@ -1,28 +0,0 @@
-/**
- * Minimum position in seconds to resume from (skip if too close to start)
- */
-export declare const RESUME_MIN_POSITION_SECONDS = 5;
-/**
- * Minimum remaining duration in seconds to resume (skip if too close to end)
- */
-export declare const RESUME_MIN_REMAINING_SECONDS = 5;
-/**
- * Interval in milliseconds between progress persistence operations
- */
-export declare const PERSIST_INTERVAL_MS = 2e3;
-export declare const getPersistedProgress: (videoId: string) => number;
-export declare const persistProgress: (videoId: string, positionMs: number) => void;
-/**
- * Determine if a saved progress position should be used to resume playback
- * @param savedPositionSeconds - The saved position in seconds
- * @param durationSeconds - The total video duration in seconds
- * @returns true if position is valid for resuming (not too close to start or end)
- */
-export declare function shouldResumeFromPosition(savedPositionSeconds: number, durationSeconds: number): boolean;
-/**
- * Determine if enough time has elapsed to persist progress again
- * @param lastPersistTime - Timestamp of last persist operation (from performance.now())
- * @param currentTime - Current timestamp (from performance.now())
- * @returns true if interval has elapsed
- */
-export declare function shouldPersistProgress(lastPersistTime: number, currentTime: number): boolean;

package/dist/lib/progress-persist.js

@@ -1,54 +0,0 @@
-// src/lib/progress-persist.ts
-const KEY = "videosdk_progress_map";
-/**
-* Minimum position in seconds to resume from (skip if too close to start)
-*/
-const RESUME_MIN_POSITION_SECONDS = 5;
-/**
-* Minimum remaining duration in seconds to resume (skip if too close to end)
-*/
-const RESUME_MIN_REMAINING_SECONDS = 5;
-/**
-* Interval in milliseconds between progress persistence operations
-*/
-const PERSIST_INTERVAL_MS = 2e3;
-const getPersistedProgress = (videoId) => {
-	if (typeof window === "undefined") return 0;
-	try {
-		const raw = window.localStorage.getItem(KEY);
-		if (!raw) return 0;
-		const map = JSON.parse(raw);
-		return Math.max(0, Math.floor(map[videoId] ?? 0));
-	} catch {
-		return 0;
-	}
-};
-const persistProgress = (videoId, positionMs) => {
-	if (typeof window === "undefined") return;
-	try {
-		const raw = window.localStorage.getItem(KEY);
-		const map = raw ? JSON.parse(raw) : {};
-		map[videoId] = Math.max(0, Math.floor(positionMs));
-		window.localStorage.setItem(KEY, JSON.stringify(map));
-	} catch {}
-};
-/**
-* Determine if a saved progress position should be used to resume playback
-* @param savedPositionSeconds - The saved position in seconds
-* @param durationSeconds - The total video duration in seconds
-* @returns true if position is valid for resuming (not too close to start or end)
-*/
-function shouldResumeFromPosition(savedPositionSeconds, durationSeconds) {
-	return savedPositionSeconds > 5 && savedPositionSeconds < durationSeconds - 5;
-}
-/**
-* Determine if enough time has elapsed to persist progress again
-* @param lastPersistTime - Timestamp of last persist operation (from performance.now())
-* @param currentTime - Current timestamp (from performance.now())
-* @returns true if interval has elapsed
-*/
-function shouldPersistProgress(lastPersistTime, currentTime) {
-	return currentTime - lastPersistTime > PERSIST_INTERVAL_MS;
-}
-
-export { PERSIST_INTERVAL_MS, RESUME_MIN_POSITION_SECONDS, RESUME_MIN_REMAINING_SECONDS, getPersistedProgress, persistProgress, shouldPersistProgress, shouldResumeFromPosition };

package/dist/lib/segment-analytics.d.ts

@@ -1,20 +0,0 @@
-import { UUID } from "../types/uuid.js";
-export interface SegmentAnalyticsParams {
-  playerId: UUID;
-  currentTimeMs: number;
-  playbackRate: number;
-  isPaused: boolean;
-}
-/**
- * Start tracking a new analytics segment
- */
-export declare function startSegment(params: SegmentAnalyticsParams): void;
-/**
- * End the current analytics segment
- */
-export declare function endSegment(params: Pick<SegmentAnalyticsParams, "playerId" | "currentTimeMs">): void;
-/**
- * Restart segment if video is currently playing
- * This is useful when playback rate changes or other segment-breaking events occur
- */
-export declare function restartSegmentIfPlaying(params: SegmentAnalyticsParams): void;

package/dist/lib/segment-analytics.js

@@ -1,29 +0,0 @@
-import { analyticsStoreActions } from "../store/analytics-store.js";
-
-// src/lib/segment-analytics.ts
-/**
-* Start tracking a new analytics segment
-*/
-function startSegment(params) {
-	const { playerId, currentTimeMs, playbackRate } = params;
-	analyticsStoreActions.startSegment(playerId, currentTimeMs, playbackRate);
-}
-/**
-* End the current analytics segment
-*/
-function endSegment(params) {
-	const { playerId, currentTimeMs } = params;
-	analyticsStoreActions.endSegment(playerId, currentTimeMs);
-}
-/**
-* Restart segment if video is currently playing
-* This is useful when playback rate changes or other segment-breaking events occur
-*/
-function restartSegmentIfPlaying(params) {
-	const { playerId, currentTimeMs, playbackRate, isPaused } = params;
-	if (isPaused) return;
-	analyticsStoreActions.endSegment(playerId, currentTimeMs);
-	analyticsStoreActions.startSegment(playerId, currentTimeMs, playbackRate);
-}
-
-export { endSegment, restartSegmentIfPlaying, startSegment };

package/dist/lib/subtitle-logic.d.ts

@@ -1,31 +0,0 @@
-export interface SubtitleTrack {
-  index: number;
-  label: string;
-  language: string;
-  kind: string;
-  track: TextTrack;
-}
-/**
- * Calculates the efficient end time for a cue to prevent flickering and ensure readability.
- */
-export declare const calculateSmoothedEndTime: (cue: TextTrackCue | VTTCue, nextCue?: TextTrackCue | VTTCue) => number;
-/**
- * Helper to find the next cue in a TextTrackCueList by reference.
- */
-export declare const findNextCue: (activeCue: TextTrackCue, allCues: TextTrackCueList | null) => TextTrackCue | undefined;
-export declare function stripHtmlTags(input: string): string;
-/**
- * Extracts and cleans text from a cue object.
- * Handles VTTCue vs TextTrackCue differences.
- */
-export declare const getCleanCueText: (cue: TextTrackCue | VTTCue) => string;
-/**
- * Applies smoothing logic to a list of cues (typically activeCues).
- * Modifies the cues in-place and caches them to avoid re-processing.
- */
-export declare const processCues: (cues: TextTrackCueList | TextTrackCue[], allCues: TextTrackCueList | null) => void;
-/**
- * Parses the video element's text tracks and extracts relevant subtitle/caption tracks.
- * Also normalizes track state.
- */
-export declare const extractSubtitleTracks: (tracks: TextTrackList) => SubtitleTrack[];

package/dist/lib/subtitle-logic.js

@@ -1,75 +0,0 @@
-import { clamp } from "./numbers.js";
-
-// src/lib/subtitle-logic.ts
-const SMOOTHING_GAP_THRESHOLD = .5;
-const MIN_SUBTITLE_DURATION = 1;
-const OVERLAP_BUFFER = .1;
-/**
-* Calculates the efficient end time for a cue to prevent flickering and ensure readability.
-*/
-const calculateSmoothedEndTime = (cue, nextCue) => {
-	let effectiveEndTime = cue.endTime;
-	if (nextCue) {
-		if (nextCue.startTime - cue.endTime <= SMOOTHING_GAP_THRESHOLD) return nextCue.startTime + OVERLAP_BUFFER;
-		const minEndTime = cue.startTime + MIN_SUBTITLE_DURATION;
-		return clamp(minEndTime, effectiveEndTime, nextCue.startTime);
-	}
-	return Math.max(effectiveEndTime, cue.startTime + MIN_SUBTITLE_DURATION);
-};
-/**
-* Helper to find the next cue in a TextTrackCueList by reference.
-*/
-const findNextCue = (activeCue, allCues) => {
-	if (!allCues || allCues.length === 0) return void 0;
-	for (let index = 0; index < allCues.length - 1; index++) if (allCues[index] === activeCue) return allCues[index + 1];
-};
-function stripHtmlTags(input) {
-	return input.replace(/<[^>]*>/g, "");
-}
-/**
-* Extracts and cleans text from a cue object.
-* Handles VTTCue vs TextTrackCue differences.
-*/
-const getCleanCueText = (cue) => {
-	return stripHtmlTags(cue instanceof VTTCue ? cue.text : cue.text ?? "");
-};
-const processedCues = /* @__PURE__ */ new WeakSet();
-/**
-* Applies smoothing logic to a list of cues (typically activeCues).
-* Modifies the cues in-place and caches them to avoid re-processing.
-*/
-const processCues = (cues, allCues) => {
-	for (let i = 0; i < cues.length; i++) {
-		const cue = cues[i];
-		if (!processedCues.has(cue)) {
-			const nextCue = findNextCue(cue, allCues);
-			const newEndTime = calculateSmoothedEndTime(cue, nextCue);
-			if (Math.abs(cue.endTime - newEndTime) > .01) cue.endTime = newEndTime;
-			processedCues.add(cue);
-		}
-	}
-};
-/**
-* Parses the video element's text tracks and extracts relevant subtitle/caption tracks.
-* Also normalizes track state.
-*/
-const extractSubtitleTracks = (tracks) => {
-	const subtitleTracks = [];
-	for (let i = 0; i < tracks.length; i++) {
-		const track = tracks[i];
-		if (track.kind === "subtitles" || track.kind === "captions") {
-			if (!track.label && !track.language && !track.id) continue;
-			subtitleTracks.push({
-				index: i,
-				label: track.label || `${track.kind} ${i + 1}`,
-				language: track.language || "unknown",
-				kind: track.kind,
-				track
-			});
-			track.mode = "disabled";
-		}
-	}
-	return subtitleTracks;
-};
-
-export { calculateSmoothedEndTime, extractSubtitleTracks, findNextCue, getCleanCueText, processCues, stripHtmlTags };

package/dist/lib/subtitle-utils.d.ts

@@ -1,16 +0,0 @@
-import { UUID } from "../types/uuid.js";
-/**
- * Structural shape of a video element ref. Compatible with React.RefObject
- * but does not depend on React, keeping this module framework-agnostic.
- */
-interface VideoElementRef {
-  current: HTMLVideoElement | null;
-}
-export declare const handleLoadedMetadata: (videoElement: HTMLVideoElement, playerId: UUID) => void;
-export declare const clearSubtitles: (playerId: UUID) => void;
-/**
- * Handles the 'cuechange' event to update subtitles.
- * Uses event-driven logic + lookahead smoothing to prevent flickering.
- */
-export declare const handleCueChange: (playerId: UUID, videoRef: VideoElementRef) => void;
-export {};

package/dist/lib/subtitle-utils.js

@@ -1,37 +0,0 @@
-import { playerStateStore } from "../store/player-store.js";
-import { extractSubtitleTracks, getCleanCueText, processCues } from "./subtitle-logic.js";
-
-// src/lib/subtitle-utils.ts
-const handleLoadedMetadata = (videoElement, playerId) => {
-	const subtitleTracks = extractSubtitleTracks(videoElement.textTracks);
-	playerStateStore.setAvailableSubtitleTracks(playerId, subtitleTracks);
-};
-const clearSubtitles = (playerId) => {
-	playerStateStore.setCurrentSubtitleText(playerId, "");
-};
-/**
-* Handles the 'cuechange' event to update subtitles.
-* Uses event-driven logic + lookahead smoothing to prevent flickering.
-*/
-const handleCueChange = (playerId, videoRef) => {
-	if (!videoRef.current) return;
-	const player = playerStateStore.get(playerId).get();
-	const index = player.subtitleTrack;
-	if (index < 0 || index >= player.availableSubtitleTracks.length) {
-		if (player.currentSubtitleText !== "") clearSubtitles(playerId);
-		return;
-	}
-	const trackObj = player.availableSubtitleTracks[index].track;
-	if (trackObj.mode !== "showing") return;
-	const activeCues = trackObj.activeCues;
-	if (!activeCues || activeCues.length === 0) {
-		if (player.currentSubtitleText !== "") playerStateStore.setCurrentSubtitleText(playerId, "");
-		return;
-	}
-	processCues(activeCues, trackObj.cues);
-	const activeCue = activeCues[activeCues.length - 1];
-	const newText = getCleanCueText(activeCue);
-	if (newText !== player.currentSubtitleText) playerStateStore.setCurrentSubtitleText(playerId, newText);
-};
-
-export { clearSubtitles, handleCueChange, handleLoadedMetadata };

package/dist/lib/time.d.ts

@@ -1 +0,0 @@
-export declare const formatTime: (seconds: number) => string;

package/dist/lib/time.js

@@ -1,17 +0,0 @@
-// src/lib/time.ts
-function leadingZero(num) {
-	let numStr = num.toString();
-	if (num < 10) numStr = "0" + numStr;
-	return numStr;
-}
-const formatTime = (seconds) => {
-	if (isNaN(seconds) || seconds < 0) return "00:00";
-	const hours = Math.floor(seconds / 3600);
-	const minutes = Math.floor(seconds % 3600 / 60);
-	const remainingSeconds = Math.floor(seconds % 60);
-	const output = `${leadingZero(minutes)}:${leadingZero(remainingSeconds)}`;
-	if (hours > 0) return `${leadingZero(hours)}:${output}`;
-	return output;
-};
-
-export { formatTime };

package/dist/lib/track-persistence.d.ts

@@ -1,4 +0,0 @@
-export declare const getPersistedSubtitleTrack: () => number;
-export declare const persistSubtitleTrack: (trackIndex: number) => void;
-export declare const getPersistedAudioTrack: () => number;
-export declare const persistAudioTrack: (trackIndex: number) => void;

package/dist/lib/track-persistence.js

@@ -1,35 +0,0 @@
-// src/lib/track-persistence.ts
-const SUBTITLE_TRACK_KEY = "video-player-subtitle-track";
-const AUDIO_TRACK_KEY = "audioTrack";
-const getPersistedSubtitleTrack = () => {
-	try {
-		const stored = localStorage.getItem(SUBTITLE_TRACK_KEY);
-		return stored !== null ? parseInt(stored, 10) : -1;
-	} catch {
-		return -1;
-	}
-};
-const persistSubtitleTrack = (trackIndex) => {
-	try {
-		localStorage.setItem(SUBTITLE_TRACK_KEY, trackIndex.toString());
-	} catch {
-		return;
-	}
-};
-const getPersistedAudioTrack = () => {
-	try {
-		const stored = localStorage.getItem(AUDIO_TRACK_KEY);
-		return stored ? parseInt(stored, 10) : 0;
-	} catch {
-		return 0;
-	}
-};
-const persistAudioTrack = (trackIndex) => {
-	try {
-		localStorage.setItem(AUDIO_TRACK_KEY, trackIndex.toString());
-	} catch {
-		return;
-	}
-};
-
-export { getPersistedAudioTrack, getPersistedSubtitleTrack, persistAudioTrack, persistSubtitleTrack };

package/dist/lib/video-preload-config.d.ts

@@ -1,34 +0,0 @@
-/**
- * PRELOAD_RANGE determines how many videos around the current one should be loaded
- *
- * Example with BEFORE: 1, AFTER: 2, current index is 5:
- *
- * Legend:
- * PRELOADING (buffering in background)
- * PLAYING (currently visible)
- * IDLE (exists but not loaded)
- * UNLOADED (too far, save memory)
- */
-export declare const PRELOAD_RANGE: {
-  BEFORE: number;
-  AFTER: number;
-};
-/**
- * UNLOAD_DISTANCE determines when to unload videos to free memory
- * If a video is more than this distance from current, unload it
- */
-export declare const UNLOAD_DISTANCE = 5;
-/**
- * Video loading states
- */
-export declare const VideoLoadState: {
-  readonly UNLOADED: "unloaded";
-  readonly IDLE: "idle";
-  readonly PRELOADING: "preloading";
-  readonly PLAYING: "playing";
-};
-export type VideoLoadState = (typeof VideoLoadState)[keyof typeof VideoLoadState];
-/**
- * Calculate what state a video should be in based on its distance from current
- */
-export declare function getVideoLoadState(videoIndex: number, currentIndex: number, isCurrent: boolean): VideoLoadState;

package/dist/lib/video-preload-config.js

@@ -1,41 +0,0 @@
-// src/lib/video-preload-config.ts
-/**
-* PRELOAD_RANGE determines how many videos around the current one should be loaded
-*
-* Example with BEFORE: 1, AFTER: 2, current index is 5:
-*
-* Legend:
-* PRELOADING (buffering in background)
-* PLAYING (currently visible)
-* IDLE (exists but not loaded)
-* UNLOADED (too far, save memory)
-*/
-const PRELOAD_RANGE = {
-	BEFORE: 0,
-	AFTER: 1
-};
-/**
-* UNLOAD_DISTANCE determines when to unload videos to free memory
-* If a video is more than this distance from current, unload it
-*/
-const UNLOAD_DISTANCE = 5;
-/**
-* Video loading states
-*/
-const VideoLoadState = {
-	UNLOADED: "unloaded",
-	IDLE: "idle",
-	PRELOADING: "preloading",
-	PLAYING: "playing"
-};
-/**
-* Calculate what state a video should be in based on its distance from current
-*/
-function getVideoLoadState(videoIndex, currentIndex, isCurrent) {
-	if (isCurrent) return VideoLoadState.PLAYING;
-	const distance = videoIndex - currentIndex;
-	if (Math.abs(distance) > 5) return VideoLoadState.UNLOADED;
-	return distance < 0 && distance >= -PRELOAD_RANGE.BEFORE || distance > 0 && distance <= PRELOAD_RANGE.AFTER ? VideoLoadState.PRELOADING : VideoLoadState.IDLE;
-}
-
-export { PRELOAD_RANGE, UNLOAD_DISTANCE, VideoLoadState, getVideoLoadState };

package/dist/lib/video-spinner.d.ts

@@ -1,25 +0,0 @@
-/**
- * Live "is the player buffering right now?" predicate.
- *
- * Different from `video-preload-config.ts` despite the similar name:
- *  - `video-preload-config.ts` decides the `<video preload>` attribute for
- *    a slot in the feed virtualization (one-time decision per slot).
- *  - `shouldShowSpinner` is called continuously during playback to decide
- *    whether the buffering spinner should currently be visible.
- *
- * Inputs come from a live `<HTMLVideoElement>`. The function is otherwise
- * pure and framework-agnostic.
- */
-/**
- * Decide whether the buffering spinner should be visible for the given
- * video element.
- *
- * Logic, in order:
- * 1. No video → never show.
- * 2. Playing past the start → if the current time falls inside any buffered
- *    range, the player has the bytes it needs; never show.
- * 3. Otherwise fall back to `readyState`/`seeking`: show when the browser
- *    reports `HAVE_CURRENT_DATA` (2) or is actively seeking with
- *    `readyState < 3` (HAVE_FUTURE_DATA).
- */
-export declare function shouldShowSpinner(video: HTMLVideoElement | null): boolean;

package/dist/lib/video-spinner.js

@@ -1,35 +0,0 @@
-// src/lib/video-spinner.ts
-/**
-* Live "is the player buffering right now?" predicate.
-*
-* Different from `video-preload-config.ts` despite the similar name:
-*  - `video-preload-config.ts` decides the `<video preload>` attribute for
-*    a slot in the feed virtualization (one-time decision per slot).
-*  - `shouldShowSpinner` is called continuously during playback to decide
-*    whether the buffering spinner should currently be visible.
-*
-* Inputs come from a live `<HTMLVideoElement>`. The function is otherwise
-* pure and framework-agnostic.
-*/
-/**
-* Decide whether the buffering spinner should be visible for the given
-* video element.
-*
-* Logic, in order:
-* 1. No video → never show.
-* 2. Playing past the start → if the current time falls inside any buffered
-*    range, the player has the bytes it needs; never show.
-* 3. Otherwise fall back to `readyState`/`seeking`: show when the browser
-*    reports `HAVE_CURRENT_DATA` (2) or is actively seeking with
-*    `readyState < 3` (HAVE_FUTURE_DATA).
-*/
-function shouldShowSpinner(video) {
-	if (!video) return false;
-	if (!video.paused && video.currentTime > 0) {
-		const buffered = video.buffered;
-		for (let i = 0; i < buffered.length; i++) if (video.currentTime >= buffered.start(i) && video.currentTime < buffered.end(i)) return false;
-	}
-	return video.readyState < 3 && (video.seeking || video.readyState === 2);
-}
-
-export { shouldShowSpinner };

package/dist/lib/video-stats.d.ts

@@ -1,28 +0,0 @@
-export interface VideoStats {
-  droppedFrames: number;
-  volume: number;
-  networkSpeed: number;
-  bufferHealth: number;
-  currentRes: {
-    width: number;
-    height: number;
-  } | null;
-  optimalRes: {
-    width: number;
-    height: number;
-  } | null;
-}
-export interface CollectStatsInput {
-  video: HTMLVideoElement | null;
-  hlsBandwidthEstimate: number | null;
-  hlsLevels: ReadonlyArray<{
-    width: number;
-    height: number;
-  }>;
-  hlsCurrentLevel: number;
-  hlsAutoLevelEnabled: boolean;
-  hlsAutoLevelCapping: number;
-}
-export declare function getDroppedFrames(video: HTMLVideoElement): number;
-export declare function getBufferHealth(video: HTMLVideoElement): number;
-export declare function collectVideoStats(input: CollectStatsInput): VideoStats;