@npo/player 2.0.0-beta.0 → 2.0.0-beta.2

package/dist/main.d.ts

@@ -39,24 +39,30 @@ declare type AirPlayConnectionState = {
     error?: string;
 };
 
-declare type AirPlayConnectionState_2 = {
-    available: boolean;
-    connected: boolean;
-    error?: string;
-};
-
 declare class AirPlayService implements IAirPlayService {
     private readonly player;
     private readonly mediaEl;
     private readonly boundCheckConnected;
+    private readonly boundCheckAvailability;
+    private isAirPlaySession;
+    private capturedAirPlayActive;
+    private apiPayload;
+    private currentLicenseUrl;
+    private currentFilter;
     constructor(player: PlayerApi);
     destroy(): void;
     private addEventListeners;
     private updateAirPlayState;
+    private unregisterCurrentFilter;
+    private registerSimpleFilter;
+    private registerRenewalFilter;
     checkAvailability(): boolean;
-    private checkConnected;
-    startAirPlay(): void;
-    stopAirPlay(): void;
+    checkConnected(): boolean;
+    showAirPlayTargetPicker(): void;
+    captureContext(): void;
+    waitForReconnect(timeoutMs?: number): Promise<void>;
+    clearSessionsForAirPlay(): void;
+    init(payload: IApiPayload, streamObject: IStreamObject): void;
 }
 
 declare type CastConnectionState = {
@@ -65,12 +71,6 @@ declare type CastConnectionState = {
     error?: string;
 };
 
-declare type CastConnectionState_2 = {
-    available: boolean;
-    connected: boolean;
-    error?: string;
-};
-
 declare type CastingData = {
     source: string;
     streamObject?: IStreamObject;
@@ -172,6 +172,11 @@ export declare const DRM_WIDEVINE = "widevine";
 
 export declare type DRMType = typeof DRM_WIDEVINE | typeof DRM_PLAYREADY | typeof DRM_FAIRPLAY;
 
+declare type EmitParams<T, K extends keyof T> = {
+    eventName: K;
+    value?: T[K];
+};
+
 declare type ErrorListener = (error: IPlayerError) => void;
 
 declare class ErrorManager implements IErrorManager {
@@ -181,7 +186,10 @@ declare class ErrorManager implements IErrorManager {
     private readonly resetListeners;
     private readonly warningListeners;
     private npoPlayerRef;
+    private debounceCleanup?;
+    private isDestroyed;
     constructor(npoPlayer: NpoPlayer);
+    destroy(): void;
     private attachGlobalErrorHandlers;
     setNpoPlayerRef(npoPlayer: NpoPlayer): void;
     onError(listener: ErrorListener): void;
@@ -232,8 +240,14 @@ declare interface IAdUiState_2 {
 
 declare interface IAirPlayService {
     checkAvailability(): boolean;
-    startAirPlay(): void;
-    stopAirPlay(): void;
+    showAirPlayTargetPicker(): void;
+}
+
+declare interface IApiPayload {
+    baseURL: string;
+    jwt: string;
+    data: Record<string, unknown>;
+    ster?: ISterData;
 }
 
 declare interface IBaseErrorConfig {
@@ -348,75 +362,84 @@ declare class InputHandler implements IInputHandler_2 {
 }
 
 export declare interface IPlayerApi {
+    airPlayService: IAirPlayService;
+    castService: {
+        isCastAvailable(): boolean;
+        isCastActive(): boolean;
+        startCastSession(): void;
+        stopCastSession(): void;
+        getCastDeviceName(): string;
+    };
     playerId: string;
-    player: unknown;
     playerEvents: IPlayerEventEmitter<IPlayerEventsMap>;
+    state: IPlayerState;
     uiEvents: any;
+    mediaStateListeners?: () => void;
+    thumbnailService?: IThumbnailTrackService;
+    chapterSkipService?: IChapterSkipService;
+    streamTrackService?: IStreamTrackService;
+    player: unknown;
+    destroy(): void;
+    initialize(): Promise<void>;
+    getPlayerContainer(): HTMLElement | null;
+    load(source: string, streamLoadingData?: IPlayerLoad): Promise<void>;
+    unload(): Promise<void>;
     play(): Promise<void>;
     pause(): void;
     togglePlayPause(): Promise<void>;
     replay(): void;
-    isLive(): boolean;
-    getMode(): Modes;
-    getSeekRange(): {
-        start: number;
-        end: number;
-    };
+    seek(time: number): void;
     forward(seconds?: number): void;
     backward(seconds?: number): void;
-    getMediaElement(): HTMLMediaElement | null;
-    getPlayerContainer(): HTMLElement | null;
-    reemit(eventName: string, data?: any): void;
-    on(eventName: string, handler: (evt: any) => void): void;
-    off(eventName: string, handler: (evt: any) => void): void;
-    once(eventName: string, handler: (evt: any) => void): void;
-    isBuffering(): boolean;
+    getCurrentTime(): number;
     getPlaybackRate(): number;
     setPlaybackRate(rate: number): void;
     getVolume(): number;
     setVolume(volume: number): void;
     mute(): void;
-    unMute(): void;
     isMuted(): boolean;
+    unMute(): void;
+    toggleMute(): void;
     isPlaying(): boolean;
+    isLive(): boolean;
+    isBuffering(): boolean;
     getDuration(): number;
-    getCurrentTime(): number;
-    seek(time: number): void;
     seekToLiveEdge(): void;
     getNetworkingEngine(): unknown;
-    removeAllTextTracks(): void;
+    getSeekRange(): {
+        start: number;
+        end: number;
+    };
+    getMediaElement(): HTMLMediaElement | null;
+    addTextTracks(subtitles: ISubtitle[]): void;
+    addTextTrack(subtitle: ISubtitle): void;
     setTextTrackVisibility(options: {
         language: string;
         persist?: boolean;
     }): void;
+    getSelectedTextTrack(): TextTrack | undefined;
+    removeAllTextTracks(): void;
     getTextTracks(): TextTrackList;
     getVariantTracks?(): Array<unknown>;
-    configure?(config: unknown): void;
-    getAvailableVideoQualities(): Array<VideoQuality>;
-    setVideoQuality(qualityValue: number, forced: boolean): void;
-    isPlayingAd?(): boolean;
-    getAdUiState?(): IAdUiState;
-    onAdEvent?(eventName: string, handler: (evt: any) => void): void;
-    offAdEvent?(eventName: string, handler: (evt: any) => void): void;
-    setAdClickElement(button: HTMLButtonElement): void;
+    isFullscreenPossible(): boolean;
     enterFullscreen(): void;
     exitFullscreen(): void;
-    isFullscreenPossible(): boolean;
     isDisplayModeChangeAllowed(): boolean;
     isPipSupported(): boolean;
     enterPip(): Promise<void>;
     exitPip(): Promise<void>;
-    castService: {
-        isCastAvailable(): boolean;
-        isCastActive(): boolean;
-        startCastSession(): void;
-        stopCastSession(): void;
-        getCastDeviceName(): string;
-    };
-    state: IPlayerState;
-    airPlayService: IAirPlayService;
-    thumbnailService?: IThumbnailTrackService;
-    chapterSkipService?: IChapterSkipService;
+    configure?(config: unknown): void;
+    on(eventName: string, handler: (evt: any) => void): void;
+    off(eventName: string, handler: (evt: any) => void): void;
+    once(eventName: string, handler: (evt: any) => void): void;
+    reemit(eventName: string, data?: any): void;
+    getConfiguration(): unknown;
+    onAdEvent?(eventName: string, handler: (evt: any) => void): void;
+    offAdEvent?(eventName: string, handler: (evt: any) => void): void;
+    isPlayingAd?(): boolean;
+    setAdClickElement(button: HTMLButtonElement): void;
+    getAdUiState?(): IAdUiState;
+    getMode(): Modes;
 }
 
 declare interface IPlayerContext {
@@ -454,6 +477,7 @@ declare interface IPlayerEventsMap {
     [PlayerEventNames.CastStateChanged]: Event;
     [PlayerEventNames.AirPlayStateChanged]: AirPlayConnectionState;
     [PlayerEventNames.AirPlayConnectionChanged]: Event;
+    [PlayerEventNames.AirPlayAvailabilityChanged]: Event;
     [PlayerEventNames.AdComplete]: Event;
     [PlayerEventNames.AdError]: {
         error: unknown;
@@ -498,38 +522,35 @@ declare interface IPlayerEventsMap {
     [PlayerEventNames.ChapterExited]: {
         action: ITimeBoundAction;
     };
+    [PlayerEventNames.StreamTrackChanged]: Event;
 }
 
-declare interface IPlayerState {
-    adActive: boolean;
-    airPlay: AirPlayConnectionState;
-    cast: CastConnectionState;
-    displayMode: DisplayModes;
-    forceUIVisible: boolean;
-    fullscreen: boolean;
-    language: string;
-    mediaState: MediaStates;
-    muted: boolean;
-    playbackQuality: number;
-    playbackRate: number;
-    subtitleLanguage: string;
-    volume: number;
+declare interface IPlayerLoad {
+    normalizedAvType?: MediaType;
+    avType?: string;
+    hasDvrWindow?: boolean;
+    isLiveStream?: boolean;
+    streamProfile?: string;
+    sourceProfile?: string;
 }
 
-declare interface IPlayerState_2 {
+declare interface IPlayerState {
     adActive: boolean;
     adPaused: boolean;
-    airPlay: AirPlayConnectionState_2;
-    cast: CastConnectionState_2;
+    airPlay: AirPlayConnectionState;
+    audioLanguage: string;
+    audioPlaybackQuality: number;
+    cast: CastConnectionState;
     displayMode: DisplayModes;
     forceUIVisible: boolean;
     fullscreen: boolean;
     language: string;
     mediaState: MediaStates;
     muted: boolean;
-    playbackQuality: number;
     playbackRate: number;
     subtitleLanguage: string;
+    useAudioDescription: boolean;
+    videoPlaybackQuality: number;
     volume: number;
 }
 
@@ -603,6 +624,14 @@ declare interface IStreamObjectStream {
     hasDvrWindow?: boolean;
 }
 
+declare interface IStreamTrackService {
+    currentTrack: StreamTrack | undefined;
+    getAvailableVideoTracks(): StreamTrack[];
+    getAudioTracksByVideoQuality(qualityValue: number): StreamTrack[];
+    getAudioOnlyTracks(): StreamTrack[];
+    setTrack(track: StreamTrack, forced: boolean): void;
+}
+
 declare interface ISubtitle {
     iso: string;
     location: string;
@@ -650,14 +679,16 @@ declare type KeyCombo_2 = {
     meta?: boolean;
 };
 
-declare type Listener = (...args: any[]) => void;
+declare type Listener<T> = (event: CustomEvent<T>) => void;
+
+declare type Listener_2 = (...args: any[]) => void;
 
 declare class LogEmitter {
-    private listeners;
+    private readonly listeners;
     emit(event: LogEventType, ...args: any[]): boolean;
-    on(event: LogEventType, listener: Listener): this;
-    once(event: LogEventType, listener: Listener): this;
-    off(event: LogEventType, listener: Listener): this;
+    on(event: LogEventType, listener: Listener_2): this;
+    once(event: LogEventType, listener: Listener_2): this;
+    off(event: LogEventType, listener: Listener_2): this;
 }
 
 export declare enum LogEventType {
@@ -688,7 +719,8 @@ export declare enum MediaType {
 export declare enum Modes {
     VOD = "vod",
     LIVE = "live",
-    LIVE_NO_DVR = "live-no-dvr"
+    LIVE_NO_DVR = "live-no-dvr",
+    NONE = "none"
 }
 
 export declare class NpoAudioPlayer extends NpoPlayerCore {
@@ -717,14 +749,14 @@ declare type NpoPlayerConfig = {
 
 declare abstract class NpoPlayerCore {
     player: PlayerApi;
+    uiFactory?: INpoAudioPlayerUIFactory | INpoVideoPlayerUIFactory;
+    errorManager: ErrorManager;
     readonly version: string;
     readonly container: HTMLElement;
     readonly npoTagProps?: NpoTagProperties;
     readonly logEmitter?: LogEmitter;
     readonly playerConfig: NpoPlayerConfig;
-    readonly uiFactory?: INpoAudioPlayerUIFactory | INpoVideoPlayerUIFactory;
     readonly settingsStore: SettingsStore;
-    readonly errorManager: ErrorManager;
     protected inputHandler: InputHandler;
     protected playerContext?: IPlayerContext;
     streamOptions: StreamOptions;
@@ -741,6 +773,8 @@ declare abstract class NpoPlayerCore {
     load(newSource: string, streamOptions?: StreamOptions): Promise<void>;
     play(): Promise<void>;
     pause(): void;
+    unload(): Promise<void>;
+    destroy(): Promise<void>;
     seek(timestamp: number): void;
     getCurrentTime(): number;
     mute(): void;
@@ -759,7 +793,7 @@ declare abstract class NpoPlayerCore {
         end: number;
     };
     seekToLiveEdge(): void;
-    getAvailableVideoQualities(): Array<VideoQuality>;
+    getAvailableVideoQualities(): Array<StreamTrack>;
     setVideoQuality(qualityValue: number): void;
     on(eventName: string, handler: EventHandler): void;
     off(eventName: string, handler: EventHandler): void;
@@ -866,27 +900,30 @@ declare class PlayerApi implements IPlayerApi {
     castService: CastService;
     advertService: AdvertService;
     readonly playerId: string;
-    readonly playerEvents: any;
-    state: IPlayerState_2;
+    readonly playerEvents: PlayerEventEmitter<IPlayerEventsMap>;
+    state: IPlayerState;
     uiEvents: any;
+    readonly mediaStateListeners: () => void;
     thumbnailService: ThumbnailTrackService;
     timeBoundActionsService: TimeBoundActionsService;
     chapterSkipService: ChapterSkipService;
     subtitlesService: SubtitlesService;
+    readonly streamTrackService: StreamTrackService;
     readonly playerConfig: NpoPlayerConfig;
     readonly container: HTMLElement;
-    private _player;
-    private streamAvType;
-    get player(): default_2.Player;
     readonly settingsStore: SettingsStore;
     private displayModeHandler;
-    private readonly canNotSeekDuringAdLabel;
     private isInitialized;
+    private _player;
+    private currentStreamMode;
+    private streamLoadingData?;
+    private readonly mediaEventListeners;
+    get player(): default_2.Player;
     constructor(container: HTMLElement, playerConfig: NpoPlayerConfig);
     destroy(): void;
     initialize(): Promise<void>;
     getPlayerContainer(): HTMLElement;
-    load(source: string, streamAvType?: MediaType): Promise<void>;
+    load(source: string, streamLoadingData?: IPlayerLoad): Promise<void>;
     unload(): Promise<void>;
     play(): Promise<void>;
     pause(): void;
@@ -924,9 +961,6 @@ declare class PlayerApi implements IPlayerApi {
     getSelectedTextTrack(): TextTrack | undefined;
     removeAllTextTracks(): void;
     getTextTracks(): TextTrackList;
-    getVariantTracks(): Array<default_2.extern.VariantTrack>;
-    getAvailableVideoQualities(): Array<VideoQuality>;
-    setVideoQuality(qualityValue: number, forced?: boolean): void;
     isFullscreenPossible(): boolean;
     enterFullscreen(): void;
     exitFullscreen(): void;
@@ -935,10 +969,12 @@ declare class PlayerApi implements IPlayerApi {
     enterPip(): Promise<void>;
     exitPip(): Promise<void>;
     configure(config: default_2.extern.PlayerConfiguration): void;
-    private _applyPersistedSettings;
-    private _setupPlaybackRateHandler;
-    private _initAirPlayService;
-    private _forwardAllMediaEvents;
+    private applyPersistedSettings;
+    private setupPlaybackRateHandler;
+    private initAirPlayService;
+    private forwardAllMediaEvents;
+    private createMediaEventForwardingHandler;
+    private readonly onLoadedMetadata;
     private toPlayerEventName;
     on(eventName: string, handler: EventHandler): void;
     off(eventName: string, handler: EventHandler): void;
@@ -951,6 +987,31 @@ declare class PlayerApi implements IPlayerApi {
     setAdClickElement(adClickElement: HTMLElement): void;
     getAdUiState(): IAdUiState_2 | undefined;
     getMode(): Modes;
+    private determineStreamMode;
+}
+
+declare class PlayerEventEmitter<T extends Record<string, any>> implements EventTarget {
+    readonly playerId?: string;
+    private readonly eventTarget;
+    private _allListeners;
+    constructor(playerId?: string);
+    emit<K extends keyof T>(params: EmitParams<T, K>): void;
+    on<K extends keyof T>(params: {
+        eventName: K;
+        listener: Listener<T[K]>;
+    }): void;
+    off<K extends keyof T>(params: {
+        eventName: K;
+        listener: Listener<T[K]>;
+    }): void;
+    once<K extends keyof T>(params: {
+        eventName: K;
+        listener: Listener<T[K]>;
+    }): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject | null): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject | null): void;
+    dispatchEvent(event: Event): boolean;
+    removeAllListeners(): void;
 }
 
 export declare enum PlayerEventNames {
@@ -959,6 +1020,7 @@ export declare enum PlayerEventNames {
     CastStateChanged = "castStateChanged",
     AirPlayStateChanged = "airPlayStateChanged",
     AirPlayConnectionChanged = "webkitcurrentplaybacktargetiswirelesschanged",
+    AirPlayAvailabilityChanged = "webkitplaybacktargetavailabilitychanged",
     AdComplete = "ad-complete",
     AdError = "ad-error",
     AdPaused = "ad-paused",
@@ -989,7 +1051,8 @@ export declare enum PlayerEventNames {
     TimeBoundActionTriggered = "time-bound-action-triggered",
     TimeBoundActionExited = "time-bound-action-exited",
     ChapterEntered = "chapter-entered",
-    ChapterExited = "chapter-exited"
+    ChapterExited = "chapter-exited",
+    StreamTrackChanged = "stream-track-changed"
 }
 
 export declare type PlayNext = {
@@ -1046,6 +1109,57 @@ export declare type StreamOptions = {
     backButtonCallback?: () => void;
 };
 
+declare type StreamTrack = {
+    id: number;
+    streamTrackId: number;
+    label: string;
+    value: number;
+    width?: number;
+    height?: number;
+    bandwidth?: number;
+    originalTrack?: any;
+    language?: string;
+    isAudioOnly: boolean;
+    isAudioDescription: boolean;
+    playlistUrl?: string;
+};
+
+declare class StreamTrackService implements IStreamTrackService {
+    private readonly player;
+    private readonly hlsManifestParser;
+    private manifestTracks;
+    private currentManifestUri;
+    private _currentTrack;
+    get currentTrack(): StreamTrack | undefined;
+    readonly idAutoTrack = -1;
+    constructor(player: PlayerApi);
+    isManifestTrackAvailable(): boolean;
+    reset(): void;
+    private getShakaPlayer;
+    getVariantTracks(): Array<default_2.extern.VariantTrack>;
+    getAudioTracks(): Array<default_2.extern.AudioTrack>;
+    getVideoTracks(): Array<default_2.extern.VideoTrack>;
+    isAudioOnly(): boolean;
+    getAvailableVideoTracks(): Array<StreamTrack>;
+    getAudioTracksByVideoQuality(qualityValue: number): StreamTrack[];
+    getAudioOnlyTracks(): StreamTrack[];
+    init(): void;
+    setTrack(track: StreamTrack, forced: boolean): void;
+    setVideoTrackByQuality(qualityValue: number): void;
+    getAlternateStreamURLForSafari(): string | undefined;
+    parseManifestForTracks(manifestUri: string): Promise<void>;
+    private mapVariantTracksToStreamTracks;
+    private addAutoRow;
+    private loadQualityDirect;
+    private loadAndResume;
+    private updatePlayerState;
+    private getVideoTracksFromManifest;
+    private setStreamTrack;
+    private setPlayerQualityState;
+    private getActiveTrack;
+    private hasChoiceOfTrack;
+}
+
 declare class SubtitlesService {
     private readonly player;
     private _isAudioOnly?;
@@ -1131,6 +1245,10 @@ declare class TimeBoundActionsService implements ITimeBoundActionsService {
     private isEvaluatingActions;
     private pendingEvaluateActions;
     private evaluateActions;
+    private getNowActiveActions;
+    private processNewActions;
+    private processExitedActions;
+    private handlePendingEvaluation;
     private detectAndSetStreamStartEpoch;
     private convertToPlayerTime;
     private isPointInTimeAction;
@@ -1148,16 +1266,6 @@ export declare enum TimeBoundActionType {
     PLAY_NEXT = "play-next"
 }
 
-declare type VideoQuality = {
-    id: number;
-    label: string;
-    value: number;
-    width?: number;
-    height?: number;
-    bandwidth?: number;
-    videoTrack: any;
-};
-
 declare type WarningListener = (warning: IPlayerError) => void;
 
 export { }

package/dist/npoplayer-audio.es.js

@@ -1,19 +1,18 @@
-import { g, f, D, L, e, d, b, M, N, a, P, h, i, T, a as a2 } from "./main-XvJyWo8j.js";
+import { g as s, f as o, D as d, L as M, e as P, d as i, b as p, M as r, N as t, a as y, P as A, h as D, i as E, T as L, a as R } from "./main-BmfZ6YEj.js";
 export {
-  g as DRM_FAIRPLAY,
-  f as DRM_PLAYREADY,
-  D as DRM_WIDEVINE,
-  L as LogEventType,
-  e as MarkerTypes,
-  d as MediaStates,
-  b as MediaType,
-  M as Modes,
-  N as NpoAudioPlayer,
-  a as NpoVideoPlayer,
-  P as PROFILE_DASH,
-  h as PROFILE_HLS,
-  i as PlayerEventNames,
-  T as TimeBoundActionType,
-  a2 as default
+  s as DRM_FAIRPLAY,
+  o as DRM_PLAYREADY,
+  d as DRM_WIDEVINE,
+  M as LogEventType,
+  P as MarkerTypes,
+  i as MediaStates,
+  p as MediaType,
+  r as Modes,
+  t as NpoAudioPlayer,
+  y as NpoVideoPlayer,
+  A as PROFILE_DASH,
+  D as PROFILE_HLS,
+  E as PlayerEventNames,
+  L as TimeBoundActionType,
+  R as default
 };
-//# sourceMappingURL=npoplayer-audio.es.js.map