@broadcastingplatforms/player 1.1.0 → 1.4.0

package/dist/bplive/service.d.ts

@@ -1,6 +1,7 @@
 import type { BPLiveConfig, BPLiveStreamResponse, BPLiveClipResponse, BPLiveSource, BPLiveStream, BPLiveClip } from './types';
 import type { ResolvedPlayerSource } from '../providers/contract';
 import type { ContentType } from '../core/state';
+import type { NetworkInterceptorController } from '../network/index';
 export interface BPLiveResolvedResult {
     source: ResolvedPlayerSource;
     contentType: ContentType;
@@ -18,9 +19,10 @@ export declare class BPLiveError extends Error {
 export declare class BPLiveService {
     private _config;
     private _authToken;
+    private _network;
     private _stream;
     private _clip;
-    constructor(config: BPLiveConfig);
+    constructor(config: BPLiveConfig, network?: NetworkInterceptorController);
     get config(): BPLiveConfig;
     get authToken(): string | null;
     get stream(): BPLiveStream | null;

package/dist/components/bp-default-ui.d.ts

@@ -48,9 +48,13 @@ export declare class BPDefaultUI extends LitElement {
     private detectMobile;
     private _getPoster;
     protected firstUpdated(_changedProperties: PropertyValues): void;
+    protected willUpdate(_changedProperties: PropertyValues): void;
     protected updated(_changedProperties: PropertyValues): void;
-    /** Set initial video dimensions from preferredOrientation hint */
-    private _setInitialVideoDimensionsFromSources;
+    /**
+     * Sets content-type eagerly so the correct controls render on first paint,
+     * and applies fluid dimension hints from preferredOrientation.
+     */
+    private _applySourceHints;
     /** Update video dimension CSS variables */
     private _updateVideoDimensions;
     /** Clear video dimension CSS variables */

package/dist/core/player-core.d.ts

@@ -1,6 +1,7 @@
 import type { PlayerState, QualityLevel, PresentationMode, ConnectionState, StreamType, PlayerError } from './state';
 import type { ProviderType, PlayerSource, ProviderConfig } from '../providers/contract';
 import { BPLiveService } from '../bplive/service';
+import type { NetworkInterceptorController } from '../network/index';
 export interface PlayerCoreEventMap {
     play: void;
     playing: void;
@@ -99,6 +100,7 @@ export interface PlayerCore {
     readonly state: PlayerState;
     readonly videoElement: HTMLVideoElement | null;
     readonly bpLive: BPLiveService | null;
+    readonly network: NetworkInterceptorController;
     /** Whether the player is ready (attached and can accept sources) */
     readonly ready: boolean;
     /** Current provider type based on loaded source */
@@ -139,12 +141,15 @@ export declare class PlayerCoreImpl implements PlayerCore {
     private _eventCleanup;
     private _destroyed;
     private _bpLive;
+    private _network;
     private _currentProviderType;
     private _ready;
+    private _loadGeneration;
     constructor();
     get state(): PlayerState;
     get videoElement(): HTMLVideoElement | null;
     get bpLive(): BPLiveService | null;
+    get network(): NetworkInterceptorController;
     get ready(): boolean;
     get providerType(): ProviderType | null;
     addEventListener<K extends PlayerCoreEventType>(type: K | K[], listener: EventListener<PlayerCoreEventMap[K]>): void;
@@ -156,9 +161,6 @@ export declare class PlayerCoreImpl implements PlayerCore {
      */
     attach(container: HTMLElement, config?: ProviderConfig): void;
     loadSource(source: string | PlayerSource, container?: HTMLElement, config?: ProviderConfig): Promise<SourceLoadResult | void>;
-    /**
-     * Destroy the current media element and clean up listeners.
-     */
     private destroyMediaElement;
     private createMediaElement;
     private attachMediaElementListeners;

package/dist/index.d.ts

@@ -12,6 +12,7 @@ export type { PlayerState, QualityLevel, PresentationMode, ConnectionState, Stre
 export { StateReceiverMixin, StateReceiverProps, isStateReceiverElement, forEachStateReceiverElement, propagateStateToReceiver, removeStateFromReceiver, } from './core/state-receiver';
 export type { StateReceiverElement, StateReceiverPropertyMap } from './core/state-receiver';
 export type { ProviderType, ProviderConfig, VideoProviderConfig, NanoProviderConfig, LiveKitProviderConfig, PlayerSource, ResolvedPlayerSource, VideoSource, NanoSource, LiveKitSource, PosterSource, PlayerSourceItem, PlayerSources, SourceDescription, } from './providers/contract';
+export type { NetworkInterceptorController, RequestInterceptor, ResponseInterceptor, InterceptableRequest, InterceptableResponse, RequestType, InterceptorRequestInit, InterceptorResponseInit, WaitUntilCallback, InterceptResult, } from './network/index';
 export { BPLiveService, BPLiveError, type BPLiveResolvedResult } from './bplive/service';
 export { isBPLiveSource, isBPLiveStreamSource, isBPLiveClipSource, } from './bplive/types';
 export type { BPLiveConfig, BPLiveSource, BPLiveStreamSource, BPLiveClipSource, BPLiveStream, BPLiveStreamResponse, BPLiveClip, BPLiveClipResponse, BPLiveChannel, BPLiveActiveStream, BPLivePlayerSource, BPLiveLiveKitPlayerSource, BPLiveNanoPlayerSource, BPLiveClipMedia, } from './bplive/types';

package/dist/network/index.d.ts

@@ -0,0 +1,2 @@
+export { NetworkInterceptorControllerImpl, type NetworkInterceptorController, type RequestInterceptor, type ResponseInterceptor, type InterceptableRequest, type InterceptableResponse, type RequestType, type InterceptorRequestInit, type InterceptorResponseInit, type WaitUntilCallback, type InterceptResult, } from './interceptor';
+//# sourceMappingURL=index.d.ts.map

package/dist/network/interceptor.d.ts

@@ -0,0 +1,87 @@
+export type RequestType = 'api' | 'manifest' | 'segment' | 'other';
+export interface InterceptorRequestInit {
+    url?: string;
+    method?: string;
+    headers?: Record<string, string>;
+}
+export interface InterceptorResponseInit {
+    status?: number;
+    headers?: Record<string, string>;
+    body?: unknown;
+}
+export type WaitUntilCallback = ((done: (error?: unknown) => void) => void) | (() => PromiseLike<void>);
+export interface InterceptableRequest {
+    readonly url: string;
+    readonly method: string;
+    readonly type: RequestType;
+    readonly headers: Record<string, string>;
+    readonly closed: boolean;
+    redirect(init: InterceptorRequestInit | string): void;
+    respondWith(response: InterceptorResponseInit): void;
+    waitUntil(fn: WaitUntilCallback): void;
+    waitUntil(promise: PromiseLike<unknown>): void;
+}
+export type RequestInterceptor = (request: InterceptableRequest) => void | PromiseLike<void>;
+export interface InterceptableResponse {
+    readonly url: string;
+    readonly status: number;
+    readonly headers: Record<string, string>;
+    readonly body: unknown;
+    readonly closed: boolean;
+    respondWith(response: InterceptorResponseInit): void;
+    waitUntil(fn: WaitUntilCallback): void;
+    waitUntil(promise: PromiseLike<unknown>): void;
+}
+export type ResponseInterceptor = (response: InterceptableResponse) => void | PromiseLike<void>;
+export interface NetworkInterceptorController {
+    addRequestInterceptor(interceptor: RequestInterceptor): void;
+    removeRequestInterceptor(interceptor: RequestInterceptor): void;
+    addResponseInterceptor(interceptor: ResponseInterceptor): void;
+    removeResponseInterceptor(interceptor: ResponseInterceptor): void;
+    intercept(request: {
+        url: string;
+        method: string;
+        type: RequestType;
+        headers: Record<string, string>;
+    }): Promise<InterceptResult>;
+    interceptResponse(response: {
+        url: string;
+        status: number;
+        headers: Record<string, string>;
+        body: unknown;
+    }): Promise<{
+        status: number;
+        headers: Record<string, string>;
+        body: unknown;
+    }>;
+}
+export interface InterceptResult {
+    url: string;
+    headers: Record<string, string>;
+    response: InterceptorResponseInit | null;
+}
+export declare class NetworkInterceptorControllerImpl implements NetworkInterceptorController {
+    private _requestInterceptors;
+    private _responseInterceptors;
+    addRequestInterceptor(interceptor: RequestInterceptor): void;
+    removeRequestInterceptor(interceptor: RequestInterceptor): void;
+    addResponseInterceptor(interceptor: ResponseInterceptor): void;
+    removeResponseInterceptor(interceptor: ResponseInterceptor): void;
+    intercept(request: {
+        url: string;
+        method: string;
+        type: RequestType;
+        headers: Record<string, string>;
+    }): Promise<InterceptResult>;
+    interceptResponse(response: {
+        url: string;
+        status: number;
+        headers: Record<string, string>;
+        body: unknown;
+    }): Promise<{
+        status: number;
+        headers: Record<string, string>;
+        body: unknown;
+    }>;
+}
+//# sourceMappingURL=interceptor.d.ts.map

package/dist/network/interceptor.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=interceptor.test.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@broadcastingplatforms/player",
-  "version": "1.1.0",
+  "version": "1.4.0",
   "description": "Universal video player web component built with Lit",
   "type": "module",
   "main": "dist/bp-player.js",
@@ -22,6 +22,18 @@
     "dist/",
     "!**/*.map"
   ],
+  "scripts": {
+    "build": "bun run build:types && bun run build:bundle",
+    "build:types": "tsc --emitDeclarationOnly",
+    "build:bundle": "node build.mjs",
+    "build:prod": "NODE_ENV=production bun run build",
+    "dev": "concurrently \"tsc --emitDeclarationOnly --watch --preserveWatchOutput\" \"node build.mjs --watch\"",
+    "dev:demo": "vite",
+    "clean": "rm -rf dist tsconfig.tsbuildinfo",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
   "dependencies": {
     "better-call": "^1.0.6",
     "custom-media-element": "^1.4.0",
@@ -36,18 +48,11 @@
     "concurrently": "^9.1.2",
     "esbuild": "^0.24.0",
     "typescript": "^5.7.2",
-    "vite": "^6.0.5"
+    "vite": "^6.0.5",
+    "vitest": "^4.1.0"
   },
   "license": "SEE LICENSE IN LICENSE",
   "publishConfig": {
     "access": "public"
-  },
-  "scripts": {
-    "build": "pnpm build:types && pnpm build:bundle",
-    "build:types": "tsc --emitDeclarationOnly",
-    "build:bundle": "node build.mjs",
-    "build:prod": "NODE_ENV=production pnpm build",
-    "dev": "concurrently \"tsc --emitDeclarationOnly --watch --preserveWatchOutput\" \"node build.mjs --watch\"",
-    "dev:demo": "vite"
   }
-}
+}

package/dist/core/events.d.ts

@@ -1,148 +0,0 @@
-/**
- * Player event system with typed events.
- * Inspired by THEOplayer's event architecture.
- */
-/**
- * Base player event interface.
- */
-export interface PlayerEvent<TType extends string = string> {
-    /** The type of the event. */
-    readonly type: TType;
-    /** The creation date of the event. */
-    readonly date: Date;
-}
-/**
- * Player event types as const for type safety.
- */
-export declare const PlayerEventType: {
-    readonly PLAY: "play";
-    readonly PAUSE: "pause";
-    readonly PLAYING: "playing";
-    readonly WAITING: "waiting";
-    readonly ENDED: "ended";
-    readonly SEEKING: "seeking";
-    readonly SEEKED: "seeked";
-    readonly TIME_UPDATE: "timeupdate";
-    readonly DURATION_CHANGE: "durationchange";
-    readonly LOAD_START: "loadstart";
-    readonly LOADED_METADATA: "loadedmetadata";
-    readonly LOADED_DATA: "loadeddata";
-    readonly CAN_PLAY: "canplay";
-    readonly CAN_PLAY_THROUGH: "canplaythrough";
-    readonly PROGRESS: "progress";
-    readonly EMPTIED: "emptied";
-    readonly VOLUME_CHANGE: "volumechange";
-    readonly RATE_CHANGE: "ratechange";
-    readonly RESIZE: "resize";
-    readonly QUALITIES_CHANGE: "qualitieschange";
-    readonly QUALITY_CHANGE: "qualitychange";
-    readonly TARGET_QUALITY_CHANGED: "targetqualitychanged";
-    readonly STATE_CHANGE: "statechange";
-    readonly READY: "ready";
-    readonly ERROR: "error";
-    readonly DESTROY: "destroy";
-};
-export type PlayerEventTypes = typeof PlayerEventType[keyof typeof PlayerEventType];
-export interface PlayEvent extends PlayerEvent<'play'> {
-}
-export interface PauseEvent extends PlayerEvent<'pause'> {
-}
-export interface PlayingEvent extends PlayerEvent<'playing'> {
-}
-export interface WaitingEvent extends PlayerEvent<'waiting'> {
-}
-export interface EndedEvent extends PlayerEvent<'ended'> {
-}
-export interface SeekingEvent extends PlayerEvent<'seeking'> {
-}
-export interface SeekedEvent extends PlayerEvent<'seeked'> {
-}
-export interface TimeUpdateEvent extends PlayerEvent<'timeupdate'> {
-    readonly currentTime: number;
-}
-export interface DurationChangeEvent extends PlayerEvent<'durationchange'> {
-    readonly duration: number;
-}
-export interface LoadStartEvent extends PlayerEvent<'loadstart'> {
-}
-export interface LoadedMetadataEvent extends PlayerEvent<'loadedmetadata'> {
-}
-export interface LoadedDataEvent extends PlayerEvent<'loadeddata'> {
-}
-export interface CanPlayEvent extends PlayerEvent<'canplay'> {
-}
-export interface CanPlayThroughEvent extends PlayerEvent<'canplaythrough'> {
-}
-export interface ProgressEvent extends PlayerEvent<'progress'> {
-}
-export interface EmptiedEvent extends PlayerEvent<'emptied'> {
-}
-export interface VolumeChangeEvent extends PlayerEvent<'volumechange'> {
-    readonly volume: number;
-    readonly muted: boolean;
-}
-export interface RateChangeEvent extends PlayerEvent<'ratechange'> {
-    readonly playbackRate: number;
-}
-export interface ResizeEvent extends PlayerEvent<'resize'> {
-    readonly videoWidth: number;
-    readonly videoHeight: number;
-}
-export interface StateChangeEvent extends PlayerEvent<'statechange'> {
-}
-export interface ReadyEvent extends PlayerEvent<'ready'> {
-}
-export interface DestroyEvent extends PlayerEvent<'destroy'> {
-}
-export interface PlayerErrorEvent extends PlayerEvent<'error'> {
-    readonly error: Error;
-    readonly code?: number;
-    readonly message: string;
-}
-/**
- * Maps player event types to their event interfaces.
- */
-export interface PlayerEventMap {
-    play: PlayEvent;
-    pause: PauseEvent;
-    playing: PlayingEvent;
-    waiting: WaitingEvent;
-    ended: EndedEvent;
-    seeking: SeekingEvent;
-    seeked: SeekedEvent;
-    timeupdate: TimeUpdateEvent;
-    durationchange: DurationChangeEvent;
-    loadstart: LoadStartEvent;
-    loadedmetadata: LoadedMetadataEvent;
-    loadeddata: LoadedDataEvent;
-    canplay: CanPlayEvent;
-    canplaythrough: CanPlayThroughEvent;
-    progress: ProgressEvent;
-    emptied: EmptiedEvent;
-    volumechange: VolumeChangeEvent;
-    ratechange: RateChangeEvent;
-    resize: ResizeEvent;
-    statechange: StateChangeEvent;
-    ready: ReadyEvent;
-    error: PlayerErrorEvent;
-    destroy: DestroyEvent;
-}
-/**
- * Creates a player event with the given type and optional data.
- */
-export declare function createPlayerEvent<TType extends keyof PlayerEventMap>(type: TType, data?: Omit<PlayerEventMap[TType], 'type' | 'date'>): PlayerEventMap[TType];
-/**
- * Creates a DOM CustomEvent that wraps a PlayerEvent.
- * Use this when dispatching events through DOM elements.
- */
-export declare function createCustomEvent<TType extends keyof PlayerEventMap>(type: TType, data?: Omit<PlayerEventMap[TType], 'type' | 'date'>): CustomEvent<PlayerEventMap[TType]>;
-/**
- * Creates a standard DOM Event with bubbles and composed.
- * Use this for simple events that don't need extra data.
- */
-export declare function createEvent(type: string): Event;
-/**
- * Creates a DOM ErrorEvent with proper structure.
- */
-export declare function createErrorEvent(error: Error, code?: number): ErrorEvent;
-//# sourceMappingURL=events.d.ts.map