@scalemule/gallop 0.0.1

package/dist/iframe.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+var chunkPKRNWEEX_cjs = require('./chunk-PKRNWEEX.cjs');
+require('./chunk-2JQGJ7NX.cjs');
+
+
+
+Object.defineProperty(exports, "GallopIframeController", {
+  enumerable: true,
+  get: function () { return chunkPKRNWEEX_cjs.GallopIframeController; }
+});

package/dist/iframe.d.cts

@@ -0,0 +1,50 @@
+import { E as EventEmitter } from './EventEmitter-CiUv3YL_.cjs';
+import { e as GallopPlayer, b as GallopConfig, P as PlayerStatus, Q as QualityLevel, a as GallopDiagnostics, G as GallopQueryMap } from './types-D9Oqcpr1.cjs';
+
+declare class GallopIframeController extends EventEmitter implements GallopPlayer {
+    private container;
+    private config;
+    private iframe;
+    private targetOrigin;
+    private isConnected;
+    private pendingCalls;
+    private stateCache;
+    private cachedQualityLevels;
+    private cachedCurrentQuality;
+    private cachedDiagnostics;
+    private sessionId;
+    private boundHandler;
+    private handshakeInterval;
+    constructor(container: HTMLElement, config: GallopConfig);
+    private createIframe;
+    private startHandshake;
+    private handleMessage;
+    private handleResponse;
+    private sendMessage;
+    private callMethod;
+    get currentTime(): number;
+    get duration(): number;
+    get paused(): boolean;
+    get status(): PlayerStatus;
+    get isFullscreen(): boolean;
+    get volume(): number;
+    set volume(v: number);
+    get muted(): boolean;
+    set muted(m: boolean);
+    get playbackRate(): number;
+    set playbackRate(r: number);
+    play(): Promise<void>;
+    pause(): Promise<void>;
+    seek(time: number): Promise<void>;
+    setQualityLevel(index: number): Promise<void>;
+    setAutoQuality(): Promise<void>;
+    toggleFullscreen(): Promise<void>;
+    getQualityLevels(): QualityLevel[];
+    getCurrentQuality(): number;
+    getDiagnostics(): GallopDiagnostics;
+    query<K extends keyof GallopQueryMap>(key: K): Promise<GallopQueryMap[K]>;
+    get connected(): boolean;
+    destroy(): void;
+}
+
+export { GallopIframeController };

package/dist/iframe.d.ts

@@ -0,0 +1,50 @@
+import { E as EventEmitter } from './EventEmitter-CkfpgRij.js';
+import { e as GallopPlayer, b as GallopConfig, P as PlayerStatus, Q as QualityLevel, a as GallopDiagnostics, G as GallopQueryMap } from './types-D9Oqcpr1.js';
+
+declare class GallopIframeController extends EventEmitter implements GallopPlayer {
+    private container;
+    private config;
+    private iframe;
+    private targetOrigin;
+    private isConnected;
+    private pendingCalls;
+    private stateCache;
+    private cachedQualityLevels;
+    private cachedCurrentQuality;
+    private cachedDiagnostics;
+    private sessionId;
+    private boundHandler;
+    private handshakeInterval;
+    constructor(container: HTMLElement, config: GallopConfig);
+    private createIframe;
+    private startHandshake;
+    private handleMessage;
+    private handleResponse;
+    private sendMessage;
+    private callMethod;
+    get currentTime(): number;
+    get duration(): number;
+    get paused(): boolean;
+    get status(): PlayerStatus;
+    get isFullscreen(): boolean;
+    get volume(): number;
+    set volume(v: number);
+    get muted(): boolean;
+    set muted(m: boolean);
+    get playbackRate(): number;
+    set playbackRate(r: number);
+    play(): Promise<void>;
+    pause(): Promise<void>;
+    seek(time: number): Promise<void>;
+    setQualityLevel(index: number): Promise<void>;
+    setAutoQuality(): Promise<void>;
+    toggleFullscreen(): Promise<void>;
+    getQualityLevels(): QualityLevel[];
+    getCurrentQuality(): number;
+    getDiagnostics(): GallopDiagnostics;
+    query<K extends keyof GallopQueryMap>(key: K): Promise<GallopQueryMap[K]>;
+    get connected(): boolean;
+    destroy(): void;
+}
+
+export { GallopIframeController };

package/dist/iframe.js

@@ -0,0 +1,2 @@
+export { GallopIframeController } from './chunk-UFFGSURS.js';
+import './chunk-SQPWH6EI.js';

package/dist/index.cjs

@@ -0,0 +1,11 @@
+'use strict';
+
+var chunkVCNMR5AB_cjs = require('./chunk-VCNMR5AB.cjs');
+require('./chunk-2JQGJ7NX.cjs');
+
+
+
+Object.defineProperty(exports, "GallopPlayerCore", {
+  enumerable: true,
+  get: function () { return chunkVCNMR5AB_cjs.GallopPlayerCore; }
+});

package/dist/index.d.cts

@@ -0,0 +1,74 @@
+import { e as GallopPlayer, b as GallopConfig, a as GallopDiagnostics, G as GallopQueryMap, Q as QualityLevel, P as PlayerStatus } from './types-D9Oqcpr1.cjs';
+export { c as GallopEventCallback, d as GallopEventMap, f as GallopTheme, S as StreamingEngine, V as VideoMetadata } from './types-D9Oqcpr1.cjs';
+import { E as EventEmitter } from './EventEmitter-CiUv3YL_.cjs';
+
+declare class GallopPlayerCore extends EventEmitter implements GallopPlayer {
+    private container;
+    private config;
+    private video;
+    private wrapper;
+    private engine;
+    private state;
+    private client;
+    private controls;
+    private bigPlayButton;
+    private loadingSpinner;
+    private errorOverlay;
+    private posterImage;
+    private themeManager;
+    private contextMenu;
+    private keyboardManager;
+    private touchManager;
+    private analyticsCollector;
+    private styleEl;
+    private debugOverlay;
+    private cspStatus;
+    private nonceStatus;
+    private destroyed;
+    private engineStats;
+    constructor(container: HTMLElement, config?: GallopConfig);
+    private createDOM;
+    private mountUI;
+    private bindVideoEvents;
+    loadVideoById(videoId: string): Promise<void>;
+    loadSource(url: string): Promise<void>;
+    getDiagnostics(): GallopDiagnostics;
+    private getBufferLength;
+    query<K extends keyof GallopQueryMap>(key: K): Promise<GallopQueryMap[K]>;
+    private initializeDebugOverlay;
+    private retry;
+    play(): Promise<void>;
+    pause(): Promise<void>;
+    togglePlay(): Promise<void>;
+    seek(time: number): Promise<void>;
+    seekForward(seconds?: number): void;
+    seekBackward(seconds?: number): void;
+    get volume(): number;
+    set volume(v: number);
+    get muted(): boolean;
+    set muted(m: boolean);
+    toggleMute(): void;
+    get currentTime(): number;
+    get duration(): number;
+    get paused(): boolean;
+    get buffered(): TimeRanges;
+    getQualityLevels(): QualityLevel[];
+    setQualityLevel(index: number): Promise<void>;
+    setAutoQuality(): Promise<void>;
+    isAutoQuality(): boolean;
+    getCurrentQuality(): number;
+    get playbackRate(): number;
+    set playbackRate(rate: number);
+    toggleFullscreen(): Promise<void>;
+    enterFullscreen(): Promise<void>;
+    exitFullscreen(): Promise<void>;
+    get isFullscreen(): boolean;
+    get status(): PlayerStatus;
+    getVideoElement(): HTMLVideoElement;
+    getWrapperElement(): HTMLElement;
+    private updateUIState;
+    destroy(): void;
+    private initializeAnalytics;
+}
+
+export { GallopConfig, GallopPlayerCore, PlayerStatus, QualityLevel };

package/dist/index.d.ts

@@ -0,0 +1,74 @@
+import { e as GallopPlayer, b as GallopConfig, a as GallopDiagnostics, G as GallopQueryMap, Q as QualityLevel, P as PlayerStatus } from './types-D9Oqcpr1.js';
+export { c as GallopEventCallback, d as GallopEventMap, f as GallopTheme, S as StreamingEngine, V as VideoMetadata } from './types-D9Oqcpr1.js';
+import { E as EventEmitter } from './EventEmitter-CkfpgRij.js';
+
+declare class GallopPlayerCore extends EventEmitter implements GallopPlayer {
+    private container;
+    private config;
+    private video;
+    private wrapper;
+    private engine;
+    private state;
+    private client;
+    private controls;
+    private bigPlayButton;
+    private loadingSpinner;
+    private errorOverlay;
+    private posterImage;
+    private themeManager;
+    private contextMenu;
+    private keyboardManager;
+    private touchManager;
+    private analyticsCollector;
+    private styleEl;
+    private debugOverlay;
+    private cspStatus;
+    private nonceStatus;
+    private destroyed;
+    private engineStats;
+    constructor(container: HTMLElement, config?: GallopConfig);
+    private createDOM;
+    private mountUI;
+    private bindVideoEvents;
+    loadVideoById(videoId: string): Promise<void>;
+    loadSource(url: string): Promise<void>;
+    getDiagnostics(): GallopDiagnostics;
+    private getBufferLength;
+    query<K extends keyof GallopQueryMap>(key: K): Promise<GallopQueryMap[K]>;
+    private initializeDebugOverlay;
+    private retry;
+    play(): Promise<void>;
+    pause(): Promise<void>;
+    togglePlay(): Promise<void>;
+    seek(time: number): Promise<void>;
+    seekForward(seconds?: number): void;
+    seekBackward(seconds?: number): void;
+    get volume(): number;
+    set volume(v: number);
+    get muted(): boolean;
+    set muted(m: boolean);
+    toggleMute(): void;
+    get currentTime(): number;
+    get duration(): number;
+    get paused(): boolean;
+    get buffered(): TimeRanges;
+    getQualityLevels(): QualityLevel[];
+    setQualityLevel(index: number): Promise<void>;
+    setAutoQuality(): Promise<void>;
+    isAutoQuality(): boolean;
+    getCurrentQuality(): number;
+    get playbackRate(): number;
+    set playbackRate(rate: number);
+    toggleFullscreen(): Promise<void>;
+    enterFullscreen(): Promise<void>;
+    exitFullscreen(): Promise<void>;
+    get isFullscreen(): boolean;
+    get status(): PlayerStatus;
+    getVideoElement(): HTMLVideoElement;
+    getWrapperElement(): HTMLElement;
+    private updateUIState;
+    destroy(): void;
+    private initializeAnalytics;
+}
+
+export { GallopConfig, GallopPlayerCore, PlayerStatus, QualityLevel };

package/dist/index.js

@@ -0,0 +1,2 @@
+export { GallopPlayerCore } from './chunk-QTV4W7FA.js';
+import './chunk-SQPWH6EI.js';

package/dist/react.cjs

@@ -0,0 +1,77 @@
+'use strict';
+
+var chunkVCNMR5AB_cjs = require('./chunk-VCNMR5AB.cjs');
+require('./chunk-2JQGJ7NX.cjs');
+var react = require('react');
+var jsxRuntime = require('react/jsx-runtime');
+
+var GallopPlayer = react.forwardRef(
+  function GallopPlayer2(props, ref) {
+    const containerRef = react.useRef(null);
+    const playerRef = react.useRef(null);
+    const {
+      className,
+      style,
+      onPlay,
+      onPause,
+      onEnded,
+      onTimeUpdate,
+      onVolumeChange,
+      onQualityChange,
+      onEngineStats,
+      onError,
+      onReady,
+      onFullscreenChange,
+      onStatusChange,
+      ...config
+    } = props;
+    react.useImperativeHandle(ref, () => ({
+      play: () => playerRef.current?.play(),
+      pause: () => playerRef.current?.pause(),
+      seek: (time) => playerRef.current?.seek(time),
+      toggleFullscreen: () => playerRef.current?.toggleFullscreen(),
+      getCore: () => playerRef.current
+    }));
+    react.useEffect(() => {
+      const container = containerRef.current;
+      if (!container) return;
+      const player = new chunkVCNMR5AB_cjs.GallopPlayerCore(container, config);
+      playerRef.current = player;
+      if (onPlay) player.on("play", onPlay);
+      if (onPause) player.on("pause", onPause);
+      if (onEnded) player.on("ended", onEnded);
+      if (onTimeUpdate) player.on("timeupdate", onTimeUpdate);
+      if (onVolumeChange) player.on("volumechange", onVolumeChange);
+      if (onQualityChange) player.on("qualitychange", onQualityChange);
+      if (onEngineStats) player.on("enginestats", onEngineStats);
+      if (onError) player.on("error", onError);
+      if (onReady) player.on("ready", onReady);
+      if (onFullscreenChange) player.on("fullscreenchange", onFullscreenChange);
+      if (onStatusChange) player.on("statuschange", onStatusChange);
+      return () => {
+        player.destroy();
+        playerRef.current = null;
+      };
+    }, [props.videoId, props.src, props.apiKey]);
+    return /* @__PURE__ */ jsxRuntime.jsx("div", { ref: containerRef, className, style });
+  }
+);
+function useGallopPlayer(config) {
+  const containerRef = react.useRef(null);
+  const playerRef = react.useRef(null);
+  react.useEffect(() => {
+    const container = containerRef.current;
+    if (!container) return;
+    const player = new chunkVCNMR5AB_cjs.GallopPlayerCore(container, config);
+    playerRef.current = player;
+    return () => {
+      player.destroy();
+      playerRef.current = null;
+    };
+  }, [config.videoId, config.src, config.apiKey]);
+  const getPlayer = react.useCallback(() => playerRef.current, []);
+  return { containerRef, getPlayer };
+}
+
+exports.GallopPlayer = GallopPlayer;
+exports.useGallopPlayer = useGallopPlayer;

package/dist/react.d.cts

@@ -0,0 +1,34 @@
+import * as react from 'react';
+import { GallopPlayerCore } from './index.cjs';
+import { b as GallopConfig, c as GallopEventCallback, d as GallopEventMap } from './types-D9Oqcpr1.cjs';
+import './EventEmitter-CiUv3YL_.cjs';
+
+interface GallopPlayerProps extends GallopConfig {
+    className?: string;
+    style?: React.CSSProperties;
+    onPlay?: () => void;
+    onPause?: () => void;
+    onEnded?: () => void;
+    onTimeUpdate?: GallopEventCallback<GallopEventMap['timeupdate']>;
+    onVolumeChange?: GallopEventCallback<GallopEventMap['volumechange']>;
+    onQualityChange?: GallopEventCallback<GallopEventMap['qualitychange']>;
+    onEngineStats?: GallopEventCallback<GallopEventMap['enginestats']>;
+    onError?: GallopEventCallback<GallopEventMap['error']>;
+    onReady?: () => void;
+    onFullscreenChange?: GallopEventCallback<GallopEventMap['fullscreenchange']>;
+    onStatusChange?: GallopEventCallback<GallopEventMap['statuschange']>;
+}
+interface GallopPlayerHandle {
+    play: () => void;
+    pause: () => void;
+    seek: (time: number) => void;
+    toggleFullscreen: () => void;
+    getCore: () => GallopPlayerCore | null;
+}
+declare const GallopPlayer: react.ForwardRefExoticComponent<GallopPlayerProps & react.RefAttributes<GallopPlayerHandle>>;
+declare function useGallopPlayer(config: GallopConfig): {
+    containerRef: react.RefObject<HTMLDivElement>;
+    getPlayer: () => GallopPlayerCore | null;
+};
+
+export { GallopConfig, GallopEventMap, GallopPlayer, GallopPlayerCore, type GallopPlayerHandle, type GallopPlayerProps, useGallopPlayer };

package/dist/react.d.ts

@@ -0,0 +1,34 @@
+import * as react from 'react';
+import { GallopPlayerCore } from './index.js';
+import { b as GallopConfig, c as GallopEventCallback, d as GallopEventMap } from './types-D9Oqcpr1.js';
+import './EventEmitter-CkfpgRij.js';
+
+interface GallopPlayerProps extends GallopConfig {
+    className?: string;
+    style?: React.CSSProperties;
+    onPlay?: () => void;
+    onPause?: () => void;
+    onEnded?: () => void;
+    onTimeUpdate?: GallopEventCallback<GallopEventMap['timeupdate']>;
+    onVolumeChange?: GallopEventCallback<GallopEventMap['volumechange']>;
+    onQualityChange?: GallopEventCallback<GallopEventMap['qualitychange']>;
+    onEngineStats?: GallopEventCallback<GallopEventMap['enginestats']>;
+    onError?: GallopEventCallback<GallopEventMap['error']>;
+    onReady?: () => void;
+    onFullscreenChange?: GallopEventCallback<GallopEventMap['fullscreenchange']>;
+    onStatusChange?: GallopEventCallback<GallopEventMap['statuschange']>;
+}
+interface GallopPlayerHandle {
+    play: () => void;
+    pause: () => void;
+    seek: (time: number) => void;
+    toggleFullscreen: () => void;
+    getCore: () => GallopPlayerCore | null;
+}
+declare const GallopPlayer: react.ForwardRefExoticComponent<GallopPlayerProps & react.RefAttributes<GallopPlayerHandle>>;
+declare function useGallopPlayer(config: GallopConfig): {
+    containerRef: react.RefObject<HTMLDivElement>;
+    getPlayer: () => GallopPlayerCore | null;
+};
+
+export { GallopConfig, GallopEventMap, GallopPlayer, GallopPlayerCore, type GallopPlayerHandle, type GallopPlayerProps, useGallopPlayer };

package/dist/react.js

@@ -0,0 +1,74 @@
+import { GallopPlayerCore } from './chunk-QTV4W7FA.js';
+import './chunk-SQPWH6EI.js';
+import { forwardRef, useRef, useImperativeHandle, useEffect, useCallback } from 'react';
+import { jsx } from 'react/jsx-runtime';
+
+var GallopPlayer = forwardRef(
+  function GallopPlayer2(props, ref) {
+    const containerRef = useRef(null);
+    const playerRef = useRef(null);
+    const {
+      className,
+      style,
+      onPlay,
+      onPause,
+      onEnded,
+      onTimeUpdate,
+      onVolumeChange,
+      onQualityChange,
+      onEngineStats,
+      onError,
+      onReady,
+      onFullscreenChange,
+      onStatusChange,
+      ...config
+    } = props;
+    useImperativeHandle(ref, () => ({
+      play: () => playerRef.current?.play(),
+      pause: () => playerRef.current?.pause(),
+      seek: (time) => playerRef.current?.seek(time),
+      toggleFullscreen: () => playerRef.current?.toggleFullscreen(),
+      getCore: () => playerRef.current
+    }));
+    useEffect(() => {
+      const container = containerRef.current;
+      if (!container) return;
+      const player = new GallopPlayerCore(container, config);
+      playerRef.current = player;
+      if (onPlay) player.on("play", onPlay);
+      if (onPause) player.on("pause", onPause);
+      if (onEnded) player.on("ended", onEnded);
+      if (onTimeUpdate) player.on("timeupdate", onTimeUpdate);
+      if (onVolumeChange) player.on("volumechange", onVolumeChange);
+      if (onQualityChange) player.on("qualitychange", onQualityChange);
+      if (onEngineStats) player.on("enginestats", onEngineStats);
+      if (onError) player.on("error", onError);
+      if (onReady) player.on("ready", onReady);
+      if (onFullscreenChange) player.on("fullscreenchange", onFullscreenChange);
+      if (onStatusChange) player.on("statuschange", onStatusChange);
+      return () => {
+        player.destroy();
+        playerRef.current = null;
+      };
+    }, [props.videoId, props.src, props.apiKey]);
+    return /* @__PURE__ */ jsx("div", { ref: containerRef, className, style });
+  }
+);
+function useGallopPlayer(config) {
+  const containerRef = useRef(null);
+  const playerRef = useRef(null);
+  useEffect(() => {
+    const container = containerRef.current;
+    if (!container) return;
+    const player = new GallopPlayerCore(container, config);
+    playerRef.current = player;
+    return () => {
+      player.destroy();
+      playerRef.current = null;
+    };
+  }, [config.videoId, config.src, config.apiKey]);
+  const getPlayer = useCallback(() => playerRef.current, []);
+  return { containerRef, getPlayer };
+}
+
+export { GallopPlayer, useGallopPlayer };