boss-web-player-sdk 1.0.2

package/dist/core.d.ts

@@ -0,0 +1,569 @@
+export declare type AnalyticsCallback = (event: AnalyticsEvent) => void;
+
+export declare interface AnalyticsEvent {
+    eventType: 'play' | 'pause' | 'seek' | 'ended' | 'complete' | 'buffering_start' | 'buffering_end' | 'stall' | 'quality_change' | 'audio_track_change' | 'volume_change' | 'speed_change' | 'subtitle_change' | 'mute' | 'fast_forward' | 'fast_backward' | 'key_moments' | 'pip_toggle' | 'fullscreen_enter' | 'fullscreen_exit' | 'cast_start' | 'cast_stop' | 'error' | 'network_error' | 'session_start' | 'video_loaded' | 'first_quartile' | 'midpoint' | 'third_quartile' | 'heartbeat' | 'watch_progress' | 'streaming_time';
+    timestamp: number;
+    currentTime: number;
+    duration: number;
+    bitrate?: number;
+    rendition?: string;
+    fromRendition?: string;
+    volume?: number;
+    speed?: number;
+    errorMessage?: string;
+    errorCode?: number;
+    isRecoverable?: boolean;
+    sessionId?: string;
+    videoId?: string;
+    deviceType?: string;
+    networkType?: string;
+    watchPercentage?: number;
+    totalWatchTime?: number;
+    streamingTime?: number;
+    adWatchTime?: number;
+    bufferingCount?: number;
+    totalBufferingTime?: number;
+    seekFrom?: number;
+    seekTo?: number;
+    isMuted?: boolean;
+    skipSeconds?: number;
+    momentTitle?: string;
+    momentTime?: number;
+    pipState?: 'entered' | 'exited';
+    audioTrack?: string;
+    subtitleLanguage?: string;
+    subtitleEnabled?: boolean;
+    isAutoSwitch?: boolean;
+}
+
+export declare class AnalyticsModule {
+    private callback?;
+    private heartbeatInterval?;
+    private watchProgressTimer?;
+    private isBuffering;
+    private sessionId;
+    private videoId;
+    private deviceType;
+    private networkType;
+    private adBreaks;
+    private isFirstPlay;
+    private watchStartTime;
+    private totalWatchTime;
+    private streamingWindowStart;
+    private streamingTime;
+    private isInAdBreak;
+    private adWatchWindowStart;
+    private adWatchTime;
+    private bufferingCount;
+    private totalBufferingTime;
+    private bufferingStartTime;
+    private milestonesHit;
+    private lastHeartbeatPosition;
+    private lastHeartbeatAt;
+    constructor(callback?: AnalyticsCallback, src?: string, seed?: AnalyticsSessionSnapshot, videoId?: string);
+    getSessionSnapshot(): AnalyticsSessionSnapshot;
+    registerCallback(callback: AnalyticsCallback): void;
+    setAdBreaks(adBreaks: Array<{
+        startTime: number;
+        endTime: number;
+    }>): void;
+    private getTotalAdDuration;
+    private getElapsedAdTime;
+    track(eventType: AnalyticsEvent['eventType'], videoEl: HTMLVideoElement, extra?: Partial<AnalyticsEvent>): void;
+    startHeartbeat(videoEl: HTMLVideoElement, getExtra: () => Partial<AnalyticsEvent>, watchProgressInterval?: number): void;
+    stopHeartbeat(): void;
+    setBuffering(isBuffering: boolean, videoEl: HTMLVideoElement, getExtra: () => Partial<AnalyticsEvent>): void;
+    setAdBreak(inAdBreak: boolean, videoEl: HTMLVideoElement): void;
+    private checkMilestones;
+    private checkStall;
+    private getTotalWatchTime;
+    private getStreamingTime;
+    private getAdWatchTime;
+    private dispatchRaw;
+    private generateSessionId;
+    private extractVideoId;
+    private getDeviceType;
+    private getNetworkType;
+}
+
+declare interface AnalyticsSessionSnapshot {
+    sessionId: string;
+    /** True once session_start has fired — a seeded module must not fire it again. */
+    sessionStartFired: boolean;
+    totalWatchTime: number;
+    streamingTime: number;
+    adWatchTime: number;
+    bufferingCount: number;
+    totalBufferingTime: number;
+    /** Quartile milestones already dispatched ('first_quartile' | 'midpoint' | 'third_quartile'). */
+    milestonesHit: string[];
+}
+
+export declare abstract class BasePlayerPlugin implements PlayerPlugin {
+    abstract id: string;
+    abstract name: string;
+    protected player: any;
+    install(player: any): void;
+    protected abstract onInstall(): void;
+    destroy(): void;
+    protected onDestroy(): void;
+}
+
+export declare class CastingModule {
+    private isCasting;
+    private castDeviceName;
+    private onCastStateChangeCallback?;
+    private onRemoteStateChangeCallback?;
+    private castContext;
+    private remotePlayer;
+    private remotePlayerController;
+    constructor();
+    private initCastApi;
+    getCastingState(): {
+        isCasting: boolean;
+        deviceName: string;
+    };
+    getRemoteState(): RemoteCastState | null;
+    /**
+     * Derives the Cast MediaInfo content type from the stream URL so HLS/DASH manifests
+     * aren't sent to the receiver mislabeled as video/mp4, which causes load failures.
+     */
+    private getContentType;
+    /**
+     * Prompts the native Google Cast device picker overlay, then loads media on the remote device.
+     * The caller is responsible for pausing local playback before/after this resolves.
+     */
+    requestSession(currentSrc: string, currentTime: number): Promise<void>;
+    /**
+     * Disconnects the current cast session.
+     */
+    stopCasting(): void;
+    remotePlayPause(): void;
+    remoteSeek(time: number): void;
+    remoteSetVolume(volume: number): void;
+    remoteSetMute(muted: boolean): void;
+    onCastStateChange(callback: (isCasting: boolean, deviceName: string) => void): void;
+    onRemoteStateChange(callback: (state: RemoteCastState) => void): void;
+    requestAirPlaySession(videoElement: HTMLVideoElement): void;
+    stopAirPlay(videoElement: HTMLVideoElement): void;
+    isAirPlayAvailable(): boolean;
+}
+
+export declare interface Chapter {
+    title: string;
+    startTime: number;
+    endTime: number;
+    thumbnail?: string;
+    description?: string;
+}
+
+export declare class ChaptersModule extends KeyMomentsModule {
+}
+
+export declare interface DRMConfig {
+    widevineLicenseUrl?: string;
+    playreadyLicenseUrl?: string;
+    fairplayLicenseUrl?: string;
+    authToken?: string;
+    authHeader?: string;
+    allowedDomains?: string[];
+    watermarkText?: string;
+}
+
+export declare class DRMModule {
+    private config?;
+    private watermarkElement?;
+    private floatInterval?;
+    constructor(config?: DRMConfig);
+    /**
+     * Validates if the active origin domain is permitted to load this stream asset.
+     */
+    validateDomain(currentDomain: string): boolean;
+    getAuthToken(): string | undefined;
+    getAuthHeader(): string | undefined;
+    getRequestHeaders(): Record<string, string>;
+    /**
+     * Injects an animated floating watermark on top of the media container to obstruct piracy or recording.
+     */
+    setupWatermark(container: HTMLElement): void;
+    /**
+     * Cleans up active watermarks.
+     */
+    removeWatermark(): void;
+    isDRMProtected(): boolean;
+    getDRMDetails(): {
+        widevine: string | null;
+        playready: string | null;
+        fairplay: string | null;
+        authTokenPresent: boolean;
+        allowedDomains: string[];
+    };
+}
+
+/**
+ * Sends all player analytics events to Firebase Analytics (GA4).
+ *
+ * Events appear in:
+ *   Firebase Console → Analytics → Events       (24-48 hr aggregated view)
+ *   Firebase Console → Analytics → DebugView    (real-time while testing)
+ *   Google Analytics 4 → Reports → Realtime     (within a few minutes)
+ *
+ * No Firestore / database setup required — Firebase Analytics handles all storage.
+ */
+export declare class FirebaseAnalyticsProvider {
+    private analytics;
+    private logEventFn;
+    private pendingEvents;
+    constructor(config: FirebaseConfig);
+    private init;
+    private flushPending;
+    createCallback(): AnalyticsCallback;
+    private handleEvent;
+    private logToFirebase;
+    private buildParams;
+    destroy(): Promise<void>;
+}
+
+export declare interface FirebaseConfig {
+    apiKey: string;
+    authDomain: string;
+    projectId: string;
+    storageBucket: string;
+    messagingSenderId: string;
+    appId: string;
+    measurementId?: string;
+}
+
+export declare type KeyMoment = Chapter;
+
+export declare class KeyMomentsModule {
+    private keyMoments;
+    private currentMomentIndex;
+    private onMomentChangeCallback?;
+    constructor(keyMoments?: KeyMoment[]);
+    /**
+     * Sorts and stores the key moments.
+     */
+    setKeyMoments(keyMoments: KeyMoment[]): void;
+    getKeyMoments(): KeyMoment[];
+    /**
+     * Locates the key moment corresponding to the active playback timestamp.
+     */
+    getCurrentMoment(currentTime: number): {
+        keyMoment: KeyMoment | null;
+        index: number;
+    };
+    /**
+     * Evaluates if playback has crossed a key moment boundary.
+     */
+    updateTime(currentTime: number): void;
+    /**
+     * Subscribes a callback to change events.
+     */
+    onMomentChange(callback: (keyMoment: KeyMoment | null, index: number) => void): void;
+    setChapters(chapters: KeyMoment[]): void;
+    getChapters(): KeyMoment[];
+    getCurrentChapter(currentTime: number): {
+        chapter: KeyMoment | null;
+        index: number;
+    };
+    onChapterChange(callback: (chapter: KeyMoment | null, index: number) => void): void;
+}
+
+export declare interface PlayerPlugin {
+    id: string;
+    name: string;
+    install(player: any): void;
+    destroy?(): void;
+}
+
+export declare interface PlayerSDKOptions {
+    container: HTMLElement;
+    src: string;
+    autoplay?: boolean;
+    muted?: boolean;
+    controls?: boolean;
+    chapters?: Chapter[];
+    keyMoments?: KeyMoment[];
+    subtitles?: SubtitleTrack[];
+    thumbnails?: ThumbnailConfig;
+    drm?: DRMConfig;
+    analyticsCallback?: AnalyticsCallback;
+    videoId?: string;
+    analyticsSessionSeed?: AnalyticsSessionSnapshot;
+    watchProgressInterval?: number;
+    themeColor?: string;
+    watermark?: string;
+    /**
+     * Optional URL transformer applied to every HLS segment/manifest request.
+     * Use this to route requests through a CORS proxy without hardcoding domains.
+     * Example: (url) => url.replace('https://cdn.example.com', '/my-proxy')
+     */
+    urlTransformer?: (url: string) => string;
+}
+
+declare interface RemoteCastState {
+    currentTime: number;
+    duration: number;
+    isPaused: boolean;
+    volumeLevel: number;
+    isMuted: boolean;
+}
+
+export declare class SubtitlesModule {
+    private tracks;
+    private activeTrackId;
+    private currentCues;
+    private activeText;
+    private onSubtitleChangeCallback?;
+    private onTrackSwitchCallback?;
+    constructor(tracks?: SubtitleTrack[]);
+    getTracks(): SubtitleTrack[];
+    getActiveTrackId(): string;
+    setHlsTracks(hlsTracks: SubtitleTrack[]): void;
+    addTrack(track: SubtitleTrack): void;
+    onTrackSwitch(callback: (track: SubtitleTrack | null) => void): void;
+    setCustomSubtitleText(text: string): void;
+    /**
+     * Switches the active track. Fetches external tracks if they need loading.
+     */
+    setActiveTrack(trackId: string): Promise<void>;
+    /**
+     * Scans the subtitle cues for the current playback position.
+     */
+    updateTime(currentTime: number): void;
+    /**
+     * Triggers the text update callback if a change in caption is detected.
+     */
+    private updateActiveText;
+    onSubtitleChange(callback: (text: string) => void): void;
+    /**
+     * Robust parser supporting WebVTT and SRT formats.
+     */
+    private parseVttOrSrt;
+}
+
+export declare interface SubtitleTrack {
+    id: string;
+    label: string;
+    lang: string;
+    src?: string;
+    isDefault?: boolean;
+    cues?: Array<{
+        startTime: number;
+        endTime: number;
+        text: string;
+    }>;
+    isHls?: boolean;
+    hlsTrackId?: number;
+    isNative?: boolean;
+    nativeTrackIndex?: number;
+}
+
+export declare interface ThumbnailConfig {
+    spriteUrl: string;
+    tileWidth: number;
+    tileHeight: number;
+    columns: number;
+    rows: number;
+    interval: number;
+    totalCount: number;
+}
+
+export declare class ThumbnailsModule {
+    private config?;
+    constructor(config?: ThumbnailConfig);
+    /**
+     * Calculates the position offset inside the sprite sheet for a given seek hover time.
+     */
+    getThumbnail(time: number): {
+        url: string;
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    } | null;
+    hasThumbnails(): boolean;
+}
+
+export declare class VideoPlayerSDK {
+    private options;
+    private videoElement;
+    private hlsInstance;
+    private dashInstance;
+    private activeQuality;
+    private qualityLevels;
+    analytics: AnalyticsModule;
+    keyMoments: KeyMomentsModule;
+    chapters: ChaptersModule;
+    subtitles: SubtitlesModule;
+    drm: DRMModule;
+    casting: CastingModule;
+    thumbnails: ThumbnailsModule;
+    private hlsSubtitleCues;
+    private hlsActiveSubtitleKey;
+    private audioTrackList;
+    private adBreaks;
+    private isAdBreak;
+    private adBreaksFromAvails;
+    private contentPlaybackRate;
+    private networkErrorRetries;
+    private mediaErrorRecovered;
+    private static readonly MAX_NETWORK_RETRIES;
+    private static readonly TERMINAL_HTTP_STATUSES;
+    private static readonly STALL_TIMEOUT_MS;
+    private stallTimer;
+    private isBuffering;
+    private progressTick;
+    private hasFailed;
+    private lastPlaybackPos;
+    private pendingSeekAttribution;
+    private eventListeners;
+    constructor(options: PlayerSDKOptions);
+    /**
+     * Builds the video DOM hierarchy, binds events, validates domain restrictions, and mounts DRM watermarks.
+     */
+    private initializePlayer;
+    /**
+     * Binds direct event listeners to the native HTML5 Video tag, routing them to our sub-packages.
+     */
+    private bindMediaEvents;
+    private rewriteToProxy;
+    /**
+     * Initializes HLS adaptive streaming through Hls.js or falls back to native browser playback.
+     */
+    private loadSource;
+    /**
+     * Sets up global lock-screen metadata and media control keys (Media Session API).
+     */
+    private setupBackgroundControls;
+    play(): void;
+    pause(): void;
+    seek(seconds: number): void;
+    /**
+     * Attributes the NEXT seek to a specific user gesture so telemetry reports it as
+     * `fast_forward` / `fast_backward` / `key_moments` instead of a generic `seek`.
+     * Call immediately before triggering the seek. The attribution expires after a
+     * short window so it can never leak onto an unrelated later seek.
+     */
+    attributeNextSeek(eventType: 'fast_forward' | 'fast_backward' | 'key_moments', extras?: Partial<AnalyticsEvent>): void;
+    setVolume(volume: number): void;
+    setMute(muted: boolean): void;
+    setPlaybackRate(rate: number): void;
+    /**
+     * Sets manual video quality rendition or switches back to auto bitrate scaling.
+     */
+    setQuality(qualityId: number): void;
+    /**
+     * Activates native Picture-in-Picture floating viewport.
+     */
+    togglePictureInPicture(): Promise<boolean>;
+    /**
+     * Requests element-level fullscreen.
+     */
+    toggleFullscreen(): void;
+    getVideoElement(): HTMLVideoElement;
+    getCurrentTime(): number;
+    getDuration(): number;
+    getVolume(): number;
+    isMuted(): boolean;
+    getPlaybackRate(): number;
+    getActiveQuality(): VideoQuality;
+    getQualityLevels(): VideoQuality[];
+    getBufferLength(): number;
+    getBufferedRanges(): Array<{
+        start: number;
+        end: number;
+    }>;
+    /**
+     * Returns true if the browser can decode at least one of the manifest's renditions.
+     *
+     * Deliberately conservative to avoid ever blocking a valid stream:
+     *  - A codec that isn't declared is treated as playable (we never assume unsupported).
+     *  - Any failure to verify (no MediaSource, isTypeSupported throws) returns true.
+     *  - The stream is "playable" if even one rendition's declared codecs are all supported,
+     *    matching how HLS.js itself selects a level.
+     * Returns false only when the browser explicitly reports every declared codec as
+     * undecodable (e.g. Dolby EC-3/AC-3 in Chrome).
+     */
+    private hasPlayableLevel;
+    private getAnalyticsPayload;
+    on(event: string, callback: (...args: any[]) => void): void;
+    off(event: string, callback: (...args: any[]) => void): void;
+    private emit;
+    private extractSubtitlesFromManifest;
+    private extractKeyMomentsFromManifest;
+    private extractAdBreaksFromManifest;
+    private buildManifestUrl;
+    private findFirstVariantUri;
+    private resolveUrl;
+    private static readonly AD_HOST_PATTERNS;
+    private static readonly AD_STITCHER_PATH_PATTERNS;
+    private static readonly AD_PATH_HINT_PATTERNS;
+    private parseSegmentUrl;
+    private isKnownAdSegment;
+    private hasAdPathHint;
+    private classifyAdGroups;
+    private mergeAdjacentRanges;
+    private parseAdBreaksFromFragments;
+    private parseAdBreaksFromPlaylist;
+    private sameAdBreaks;
+    private isTimeInAdBreak;
+    /**
+     * Syncs isAdBreak/playbackRate/ad-mode UI state against `time` and emits
+     * adbreakchange on transitions. Called from timeupdate, but also called
+     * eagerly as soon as ad breaks or metadata become known — timeupdate alone
+     * doesn't fire until playback actually starts, which left a preroll ad's
+     * first frame briefly showing content controls (rewind/forward, etc.)
+     * while autoplay was blocked or the source was still buffering.
+     */
+    private refreshAdBreakState;
+    /**
+     * Converts raw (stitched) video time to content-only time by subtracting the
+     * ad time elapsed before `time`. During an ad break the result is frozen at
+     * the content timestamp where the break started. Identity when no ad breaks
+     * are known. Mirrors the seekbar mapping in the UI layer.
+     */
+    private videoTimeToContentTime;
+    getAdBreaks(): Array<{
+        startTime: number;
+        endTime: number;
+    }>;
+    setAdBreaks(breaks: Array<{
+        startTime: number;
+        endTime: number;
+    }>): void;
+    isInAdBreak(): boolean;
+    getAudioTracks(): Array<{
+        id: number;
+        label: string;
+        lang: string;
+    }>;
+    setAudioTrack(id: number): void;
+    /**
+     * Arms a one-shot timer while buffering. If the timer fires and no data has
+     * arrived since it was armed (progressTick unchanged) and we're still
+     * buffering, the stream is considered dead. If data did arrive but we're still
+     * buffering (slow connection), it re-arms for another window rather than
+     * failing — so slow internet never trips it.
+     */
+    private armStallWatchdog;
+    private clearStallWatchdog;
+    /**
+     * Terminal error path: emit 'error' (which drives the error screen) and tear
+     * down the player. Guarded so it runs at most once, no matter how many error
+     * events fire during teardown.
+     */
+    private fail;
+    destroy(): void;
+}
+
+export declare interface VideoQuality {
+    id: number;
+    height: number;
+    width: number;
+    bitrate: number;
+    label: string;
+}
+
+export { }

package/dist/core.js

@@ -0,0 +1,16 @@
+import { a as e, c as t, i as n, l as r, n as i, o as a, r as o, s, t as c } from "./src-B8eoxemB.js";
+//#region ../plugins/src/plugins.ts
+var l = class {
+	player;
+	install(e) {
+		this.player = e, this.onInstall();
+	}
+	destroy() {
+		this.onDestroy();
+	}
+	onDestroy() {}
+};
+//#endregion
+export { r as AnalyticsModule, l as BasePlayerPlugin, o as CastingModule, a as ChaptersModule, n as DRMModule, t as FirebaseAnalyticsProvider, s as KeyMomentsModule, e as SubtitlesModule, i as ThumbnailsModule, c as VideoPlayerSDK };
+
+//# sourceMappingURL=core.js.map

package/dist/core.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"core.js","names":[],"sources":["../../plugins/src/plugins.ts"],"sourcesContent":["export interface PlayerPlugin {\r\n  id: string;\r\n  name: string;\r\n  install(player: any): void;\r\n  destroy?(): void;\r\n}\r\n\r\nexport abstract class BasePlayerPlugin implements PlayerPlugin {\r\n  public abstract id: string;\r\n  public abstract name: string;\r\n  protected player: any;\r\n\r\n  public install(player: any): void {\r\n    this.player = player;\r\n    this.onInstall();\r\n  }\r\n\r\n  protected abstract onInstall(): void;\r\n\r\n  public destroy(): void {\r\n    this.onDestroy();\r\n  }\r\n\r\n  protected onDestroy(): void {}\r\n}\r\n"],"mappings":";;AAOA,IAAsB,IAAtB,MAA+D;CAG7D;CAEA,QAAe,GAAmB;EAEhC,AADA,KAAK,SAAS,GACd,KAAK,UAAU;CACjB;CAIA,UAAuB;EACrB,KAAK,UAAU;CACjB;CAEA,YAA4B,CAAC;AAC/B"}