react-native-video-provider 0.1.1

package/src/types/events.ts

@@ -0,0 +1,22 @@
+import type { PlayerMode, VideoError, VideoSource } from './video';
+
+export interface VideoEventMap {
+  onLoad: { videoId: string; duration: number; width: number; height: number };
+  onReady: { videoId: string };
+  onPlay: undefined;
+  onPause: undefined;
+  onBuffer: { buffering: boolean };
+  onSeek: { position: number };
+  onProgress: { position: number; duration: number; buffered: number };
+  onEnd: undefined;
+  onError: VideoError;
+  onEnterFullscreen: undefined;
+  onExitFullscreen: undefined;
+  onAttach: { surfaceId: string };
+  onDetach: { surfaceId: string };
+  onModeChanged: { mode: PlayerMode };
+  onVideoChanged: { video: VideoSource | null };
+  onPipChanged: { active: boolean };
+}
+
+export type VideoEventName = keyof VideoEventMap;

package/src/types/index.ts

@@ -0,0 +1,11 @@
+export type {
+  VideoSource,
+  ResizeMode,
+  PlayerMode,
+  PlaybackStatus,
+  VideoError,
+  VideoState,
+  SetSourceOptions,
+  VideoProviderConfig,
+} from './video';
+export type { VideoEventMap, VideoEventName } from './events';

package/src/types/video.ts

@@ -0,0 +1,85 @@
+export interface VideoSource {
+  /**
+   * Stable identity of the video. The engine uses this for same-video
+   * handoff: setting a source whose `id` matches the current one never
+   * reloads, rebuffers or resets position.
+   */
+  id: string;
+  uri: string;
+  headers?: Record<string, string>;
+  title?: string;
+  artist?: string;
+  artworkUri?: string;
+  /** Seconds. Applied only when the item is (re)loaded. */
+  startPosition?: number;
+}
+
+export type ResizeMode = 'contain' | 'cover' | 'stretch';
+
+export type PlayerMode =
+  'inline' | 'fullscreen' | 'floating' | 'pip' | 'background' | 'hidden';
+
+export type PlaybackStatus =
+  | 'idle'
+  | 'loading'
+  | 'ready'
+  | 'playing'
+  | 'paused'
+  | 'buffering'
+  | 'ended'
+  | 'error';
+
+export interface VideoError {
+  code: string;
+  message: string;
+}
+
+export interface VideoState {
+  currentVideo: VideoSource | null;
+  status: PlaybackStatus;
+  playing: boolean;
+  paused: boolean;
+  buffering: boolean;
+  loading: boolean;
+  /** Seconds */
+  position: number;
+  /** Seconds. 0 until loaded. */
+  duration: number;
+  /** Seconds of buffered media ahead of position. */
+  buffered: number;
+  rate: number;
+  volume: number;
+  muted: boolean;
+  repeat: boolean;
+  resizeMode: ResizeMode;
+  fullscreen: boolean;
+  pip: boolean;
+  floating: boolean;
+  mode: PlayerMode;
+  /** Surface the player is currently requested/attached to. */
+  surfaceId: string | null;
+  videoWidth: number;
+  videoHeight: number;
+  error: VideoError | null;
+}
+
+export interface SetSourceOptions {
+  /** Start playing as soon as ready (or immediately on handoff). Default true. */
+  autoplay?: boolean;
+  /** Attach the player to this surface as part of setting the source. */
+  surfaceId?: string;
+}
+
+export interface VideoProviderConfig {
+  /**
+   * Render the built-in fullscreen host (a Modal that unlocks rotation).
+   * Set false if you render your own fullscreen surface. Default true.
+   */
+  fullscreenHost?: boolean;
+  /**
+   * Render the built-in draggable floating player host. Default true.
+   */
+  floatingHost?: boolean;
+  /** Pause playback when the active surface unmounts. Default false. */
+  pauseOnDetach?: boolean;
+}

package/src/utils/Emitter.ts

@@ -0,0 +1,51 @@
+export type Listener<P> = (payload: P) => void;
+
+export interface Subscription {
+  remove(): void;
+}
+
+/**
+ * Minimal typed event emitter. Listener errors are isolated so one broken
+ * subscriber cannot break playback state propagation.
+ */
+export class Emitter<Events extends object> {
+  private listeners = new Map<keyof Events, Set<Listener<never>>>();
+
+  addListener<K extends keyof Events>(
+    event: K,
+    listener: Listener<Events[K]>
+  ): Subscription {
+    let set = this.listeners.get(event);
+    if (!set) {
+      set = new Set();
+      this.listeners.set(event, set);
+    }
+    set.add(listener as Listener<never>);
+    return {
+      remove: () => {
+        set.delete(listener as Listener<never>);
+      },
+    };
+  }
+
+  emit<K extends keyof Events>(event: K, payload: Events[K]): void {
+    const set = this.listeners.get(event);
+    if (!set) {
+      return;
+    }
+    for (const listener of Array.from(set)) {
+      try {
+        (listener as Listener<Events[K]>)(payload);
+      } catch (e) {
+        console.error(
+          `[react-native-video-provider] listener for ${String(event)} threw`,
+          e
+        );
+      }
+    }
+  }
+
+  removeAll(): void {
+    this.listeners.clear();
+  }
+}

package/src/utils/formatTime.ts

@@ -0,0 +1,12 @@
+export function formatTime(totalSeconds: number): string {
+  if (!Number.isFinite(totalSeconds) || totalSeconds < 0) {
+    return '0:00';
+  }
+  const s = Math.floor(totalSeconds);
+  const hours = Math.floor(s / 3600);
+  const minutes = Math.floor((s % 3600) / 60);
+  const seconds = s % 60;
+  const mm = hours > 0 ? String(minutes).padStart(2, '0') : String(minutes);
+  const ss = String(seconds).padStart(2, '0');
+  return hours > 0 ? `${hours}:${mm}:${ss}` : `${mm}:${ss}`;
+}