@broadcastingplatforms/player 0.0.0-dev.0c8c26d

package/dist/bplive/index.d.ts

@@ -0,0 +1,4 @@
+export { BPLiveService, BPLiveError, type BPLiveResolvedResult } from './service';
+export type { BPLiveConfig, BPLiveSource, BPLiveStreamSource, BPLiveClipSource, BPLiveStream, BPLiveStreamResponse, BPLiveClip, BPLiveClipResponse, BPLiveChannel, BPLiveActiveStream, BPLivePlayerSource, BPLiveLiveKitPlayerSource, BPLiveNanoPlayerSource, BPLiveClipMedia, } from './types';
+export { isBPLiveSource, isBPLiveStreamSource, isBPLiveClipSource, } from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/bplive/service.d.ts

@@ -0,0 +1,40 @@
+import type { BPLiveConfig, BPLiveStreamResponse, BPLiveClipResponse, BPLiveSource, BPLiveStream, BPLiveClip } from './types';
+import type { ResolvedPlayerSource } from '../providers/contract';
+import type { ContentType } from '../core/state';
+export interface BPLiveResolvedResult {
+    source: ResolvedPlayerSource;
+    contentType: ContentType;
+    poster?: string;
+    /** Video width from media metadata */
+    videoWidth?: number;
+    /** Video height from media metadata */
+    videoHeight?: number;
+}
+export declare class BPLiveError extends Error {
+    code: string;
+    status?: number | undefined;
+    constructor(message: string, code: string, status?: number | undefined);
+}
+export declare class BPLiveService {
+    private _config;
+    private _authToken;
+    private _stream;
+    private _clip;
+    constructor(config: BPLiveConfig);
+    get config(): BPLiveConfig;
+    get authToken(): string | null;
+    get stream(): BPLiveStream | null;
+    get clip(): BPLiveClip | null;
+    private fetch;
+    getStream(streamId: number): Promise<BPLiveStreamResponse>;
+    getClip(clipId: number): Promise<BPLiveClipResponse>;
+    private mapPlayerSourceToResolvedSource;
+    private selectClipMedia;
+    private mapClipMediaToPlayerSource;
+    resolveSource(source: BPLiveSource): Promise<BPLiveResolvedResult>;
+    private extractStreamPoster;
+    private resolveStreamSource;
+    private resolveClipSource;
+    destroy(): void;
+}
+//# sourceMappingURL=service.d.ts.map

package/dist/bplive/types.d.ts

@@ -0,0 +1,207 @@
+export type BPLiveStreamSource = {
+    type: 'bplive';
+    streamId: number;
+};
+export type BPLiveClipSource = {
+    type: 'bplive';
+    clipId: number;
+    preferredOrientation?: 'landscape' | 'portrait';
+};
+export type BPLiveSource = BPLiveStreamSource | BPLiveClipSource;
+export interface BPLiveConfig {
+    discoveryUrl: string;
+    authToken?: string;
+}
+export interface BPLiveChannel {
+    id: number;
+    slug: string;
+    user_login: string;
+    title: string;
+    description: string | null;
+    cover_image: string | null;
+    is_active: boolean;
+    follower_count: number;
+    is_following: boolean;
+    nick_name: string;
+    display_name: string;
+    bio: string;
+    avatar_url: string | null;
+    cover_photo_url: string | null;
+    status: string;
+    timezone: string;
+    links: Array<{
+        id: number;
+        provider: string | null;
+        url: string;
+        last_updated: string;
+    }>;
+}
+export interface BPLiveStreamTag {
+    id: number;
+    name: string;
+}
+export interface BPLiveVodMedia {
+    file_name: string;
+    mime_type: string | null;
+    original: string;
+    thumb: string | null;
+    collection_name: string | null;
+    duration: number;
+    created_at: string;
+    media_type: string;
+    dimension: {
+        width: number;
+        height: number;
+    };
+}
+export interface BPLiveStreamMedia {
+    vod: BPLiveVodMedia[];
+    clips: unknown[];
+}
+export interface BPLiveLiveKitPlayerSource {
+    provider: 'livekit';
+    url: string;
+    token: string;
+    room?: string;
+}
+export interface BPLiveNanoPlayerSource {
+    provider: 'nanoplayer';
+    id: string;
+    h5live: {
+        server: {
+            websocket: string;
+            hls: string;
+        };
+        rtmp: {
+            url: string;
+            streamname: string;
+        };
+        security: {
+            expires: string;
+            tag: string;
+            token: string;
+            options: string;
+        };
+    };
+    startIndex: number;
+    options: {
+        switch: {
+            method: string;
+            pauseOnError: boolean;
+            forcePlay: boolean;
+            fastStart: boolean;
+            timeout: number;
+            incTiming: boolean;
+            timestampReset: boolean;
+        };
+        adaption: {
+            rule: string;
+        };
+    };
+    entries: Array<{
+        index: number;
+        label: string;
+        tag: string;
+        info: {
+            bitrate: number;
+            width: number;
+            height: number;
+            framerate: number;
+        };
+        h5live: {
+            server: {
+                websocket: string;
+                hls: string;
+            };
+            rtmp: {
+                url: string;
+                streamname: string;
+            };
+            security: {
+                expires: string;
+                tag: string;
+                token: string;
+                options: string;
+            };
+        };
+    }>;
+}
+export type BPLivePlayerSource = BPLiveLiveKitPlayerSource | BPLiveNanoPlayerSource;
+export interface BPLiveActiveStream {
+    id: number;
+    title: string;
+    viewer_count?: number;
+    started_at: string;
+    player_source: BPLivePlayerSource;
+    tags?: BPLiveStreamTag[];
+    description?: string;
+}
+export interface BPLiveStream {
+    id: number;
+    type: string;
+    title: string;
+    description: string | null;
+    stream_name: string;
+    started_at: string | null;
+    ended_at: string | null;
+    cover_photo: string | null;
+    tags: BPLiveStreamTag[];
+    channel: BPLiveChannel;
+    created_at: string;
+    created_at_formated: string;
+    updated_at: string;
+    scheduled_at: string | null;
+    is_expired: boolean;
+    is_locked: boolean;
+    media: BPLiveStreamMedia;
+    /** Player source returned directly from /streams/{id} endpoint */
+    player_source?: BPLivePlayerSource;
+    /** Active stream (used in channel endpoint responses) */
+    active_stream?: BPLiveActiveStream;
+}
+export interface BPLiveStreamResponse {
+    data: BPLiveStream;
+}
+export interface BPLiveClipMedia {
+    id: number;
+    url: string;
+    type: 'preview' | 'clip';
+    orientation: 'landscape' | 'portrait';
+    width: number;
+    height: number;
+    duration: number;
+    thumbnail: string | null;
+    created_at: string;
+}
+export interface BPLiveClipMetadata {
+    width: number;
+    height: number;
+    duration: number;
+    end_time: number;
+    start_time: number;
+}
+export interface BPLiveClip {
+    id: number;
+    title: string;
+    metadata: BPLiveClipMetadata;
+    context: Array<{
+        width: number;
+        height: number;
+        duration: number;
+        thumb_id: number;
+    }>;
+    status: string;
+    media: BPLiveClipMedia[];
+    nick_name: string;
+    privacy: string;
+    created_at: string;
+    playlists: unknown[];
+    channel: BPLiveChannel;
+}
+export interface BPLiveClipResponse {
+    data: BPLiveClip;
+}
+export declare function isBPLiveStreamSource(source: unknown): source is BPLiveStreamSource;
+export declare function isBPLiveClipSource(source: unknown): source is BPLiveClipSource;
+export declare function isBPLiveSource(source: unknown): source is BPLiveSource;
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1,66 @@
+import { LitElement, PropertyValues } from 'lit';
+import type { PlayerCore } from '../core/player-core';
+import type { ProviderConfig, SourceDescription } from '../providers/contract';
+import 'media-chrome';
+import 'media-chrome/menu';
+import './bp-player';
+import './bp-error-display';
+import type { BPLiveService } from '../bplive/service';
+export type BPDefaultUIReadyEvent = CustomEvent<PlayerCore>;
+declare global {
+    interface HTMLElementTagNameMap {
+        'bp-default-ui': BPDefaultUI;
+    }
+    interface HTMLElementEventMap {
+        ready: BPDefaultUIReadyEvent;
+    }
+}
+/**
+ * Complete player UI with controls, loading states, and error handling.
+ * Uses light DOM for NanoPlayer compatibility.
+ */
+export declare class BPDefaultUI extends LitElement {
+    protected createRenderRoot(): HTMLElement | DocumentFragment;
+    connectedCallback(): void;
+    disconnectedCallback(): void;
+    source?: SourceDescription;
+    autoplay: boolean;
+    muted: boolean;
+    loop: boolean;
+    poster?: string;
+    scaling: 'letterbox' | 'crop' | 'fill';
+    aspectRatio?: string;
+    config?: ProviderConfig;
+    debug: boolean;
+    autohide: number;
+    hotkeys: boolean;
+    mobile: boolean;
+    live: boolean;
+    /** When set, automatically adjusts aspect ratio to match the video content */
+    fluid: boolean;
+    private _player;
+    private _providerType;
+    private _error;
+    private _connectionState;
+    private _showEndedOverlay;
+    private _cleanupListeners;
+    get player(): PlayerCore | null;
+    get mediaController(): HTMLElement | null;
+    get bpLive(): BPLiveService | null;
+    private detectMobile;
+    private _getPoster;
+    protected firstUpdated(_changedProperties: PropertyValues): void;
+    protected updated(_changedProperties: PropertyValues): void;
+    /** Set initial video dimensions from preferredOrientation hint */
+    private _setInitialVideoDimensionsFromSources;
+    /** Update video dimension CSS variables */
+    private _updateVideoDimensions;
+    /** Clear video dimension CSS variables */
+    private _clearVideoDimensions;
+    private _moveSlottedContent;
+    private setupPlayer;
+    private setupPlayerListeners;
+    private renderDefaultControls;
+    protected render(): import("lit").TemplateResult<1>;
+}
+//# sourceMappingURL=bp-default-ui.d.ts.map

package/dist/components/bp-error-display.d.ts

@@ -0,0 +1,30 @@
+import { LitElement } from 'lit';
+import type { PlayerError } from '../core/state';
+declare global {
+    interface HTMLElementTagNameMap {
+        'bp-error-display': BPErrorDisplay;
+    }
+}
+/**
+ * `<bp-error-display>` - Displays error information with icon, heading, and message.
+ *
+ * @slot icon - Custom icon to display
+ * @slot heading - Custom heading text (for i18n)
+ * @slot message - Custom message (overrides error.message)
+ * @slot code - Custom error code display
+ * @slot actions - Action buttons (e.g., fullscreen button, retry button)
+ *
+ * @csspart icon - The icon container
+ * @csspart heading - The heading element
+ * @csspart message - The message element
+ * @csspart code - The error code element
+ * @csspart actions - The actions container
+ */
+export declare class BPErrorDisplay extends LitElement {
+    static styles: import("lit").CSSResult;
+    error: PlayerError | null;
+    showCode: boolean;
+    render(): import("lit").TemplateResult<1> | null;
+    private renderIcon;
+}
+//# sourceMappingURL=bp-error-display.d.ts.map

package/dist/components/bp-overlay.d.ts

@@ -0,0 +1,29 @@
+import { LitElement } from 'lit';
+export type OverlayType = 'loading' | 'offline' | 'ended' | 'none';
+declare global {
+    interface HTMLElementTagNameMap {
+        'bp-overlay': BPOverlay;
+    }
+}
+/**
+ * `<bp-overlay>` - Displays overlay states like loading, offline, or ended.
+ *
+ * @slot icon - Custom icon to display
+ * @slot message - Custom message text (for i18n)
+ * @slot submessage - Custom submessage text
+ *
+ * @csspart icon - The icon container
+ * @csspart message - The message element
+ * @csspart submessage - The submessage element
+ */
+export declare class BPOverlay extends LitElement {
+    static styles: import("lit").CSSResult;
+    type: OverlayType;
+    live: boolean;
+    buttonMode: boolean;
+    private getIcon;
+    private getDefaultMessage;
+    render(): import("lit").TemplateResult<1> | null;
+    private renderIcon;
+}
+//# sourceMappingURL=bp-overlay.d.ts.map

package/dist/components/bp-player.d.ts

@@ -0,0 +1,86 @@
+import { LitElement, type PropertyValues } from 'lit';
+import { type PlayerCore } from '../core/player-core';
+import type { PlayerState } from '../core/state';
+import type { ProviderType, ProviderConfig, SourceDescription } from '../providers/contract';
+import type { BPLiveService } from '../bplive/service';
+import { VideoRenditionList } from './video-rendition-list';
+export type BPPlayerReadyEvent = CustomEvent<PlayerCore>;
+declare global {
+    interface HTMLElementTagNameMap {
+        'bp-player': BPPlayer;
+    }
+    interface HTMLElementEventMap {
+        'ready': BPPlayerReadyEvent;
+    }
+}
+export declare class BPPlayer extends LitElement {
+    protected createRenderRoot(): HTMLElement | DocumentFragment;
+    connectedCallback(): void;
+    source?: SourceDescription;
+    autoplay: boolean;
+    defaultMuted: boolean;
+    loop: boolean;
+    scaling: 'letterbox' | 'crop' | 'fill';
+    aspectRatio?: string;
+    config?: ProviderConfig;
+    debug: boolean;
+    private _playerCore;
+    private containerRef;
+    private providerContainer;
+    private eventCleanup;
+    private stateReceivers;
+    private _mutationObserver;
+    private _videoRenditions;
+    private _hasDispatchedReady;
+    get player(): PlayerCore | null;
+    get playerState(): PlayerState | null;
+    get bpLive(): BPLiveService | null;
+    play(): Promise<void>;
+    pause(): void;
+    get paused(): boolean;
+    get ended(): boolean;
+    get seeking(): boolean;
+    get waiting(): boolean;
+    get currentTime(): number;
+    set currentTime(value: number);
+    get duration(): number;
+    get volume(): number;
+    set volume(value: number);
+    get muted(): boolean;
+    set muted(value: boolean);
+    get playbackRate(): number;
+    set playbackRate(value: number);
+    get readyState(): number;
+    get buffered(): TimeRanges;
+    get videoWidth(): number;
+    get videoHeight(): number;
+    get videoElement(): HTMLVideoElement | null;
+    get providerType(): ProviderType | null;
+    get videoRenditions(): VideoRenditionList | null;
+    disconnectedCallback(): void;
+    protected firstUpdated(_changedProperties: PropertyValues): void;
+    protected updated(changedProperties: PropertyValues): void;
+    /**
+     * Initialize player core once. Called in firstUpdated.
+     */
+    private initPlayerCore;
+    /**
+     * Load source into player core. Player core handles provider switching internally.
+     */
+    private loadSource;
+    private handleMutation;
+    private registerStateReceiver;
+    private unregisterStateReceiver;
+    private propagateStateToAllReceivers;
+    private setupEventForwarding;
+    private updateStateAttributes;
+    private destroyPlayer;
+    /** Update video dimension CSS variables */
+    updateVideoDimensions(width: number, height: number): void;
+    /** Clear video dimension CSS variables */
+    private clearVideoDimensions;
+    private getContainerClasses;
+    private getContainerStyle;
+    protected render(): import("lit").TemplateResult<1>;
+}
+//# sourceMappingURL=bp-player.d.ts.map

package/dist/components/index.d.ts

@@ -0,0 +1,6 @@
+export { BPPlayer, type BPPlayerReadyEvent } from './bp-player';
+export { BPDefaultUI, type BPDefaultUIReadyEvent } from './bp-default-ui';
+export { BPErrorDisplay } from './bp-error-display';
+export { BPOverlay, type OverlayType } from './bp-overlay';
+export { VideoRenditionList, type VideoRendition, type VideoRenditionHost } from './video-rendition-list';
+//# sourceMappingURL=index.d.ts.map

package/dist/components/video-rendition-list.d.ts

@@ -0,0 +1,38 @@
+import type { PlayerCore } from '../core/player-core';
+/**
+ * Represents a single video rendition/quality level.
+ * Compatible with media-chrome's VideoRendition interface.
+ */
+export interface VideoRendition {
+    id: string;
+    width: number;
+    height: number;
+    bitrate: number;
+    selected: boolean;
+}
+/**
+ * Interface for the player host that provides access to PlayerCore.
+ */
+export interface VideoRenditionHost {
+    readonly player: PlayerCore | null;
+}
+/**
+ * VideoRenditionList provides media-chrome compatibility for quality selection.
+ * It exposes video quality levels as an iterable list with selection support.
+ */
+export declare class VideoRenditionList extends EventTarget {
+    [index: number]: VideoRendition;
+    private _host;
+    private _renditions;
+    private _cleanup;
+    constructor(host: VideoRenditionHost);
+    get length(): number;
+    [Symbol.iterator](): Iterator<VideoRendition>;
+    get selectedIndex(): number;
+    set selectedIndex(index: number);
+    private _updateSelection;
+    _syncFromPlayer(): void;
+    _setupListeners(): void;
+    _destroy(): void;
+}
+//# sourceMappingURL=video-rendition-list.d.ts.map

package/dist/core/index.d.ts

@@ -0,0 +1,7 @@
+export { createPlayerCore, PlayerCoreImpl } from './player-core';
+export type { PlayerCore, PlayerCoreEventMap, PlayerCoreEventType, SourceLoadResult } from './player-core';
+export { createInitialState, classifyNanoPlayerError, classifyLiveKitError, NANOPLAYER_NO_REPLAY_CODES } from './state';
+export type { PlayerState, QualityLevel, PresentationMode, ConnectionState, StreamType, ProviderType, PlayerError, ErrorCategory, } from './state';
+export { StateReceiverMixin, StateReceiverProps, isStateReceiverElement, forEachStateReceiverElement, propagateStateToReceiver, removeStateFromReceiver, } from './state-receiver';
+export type { StateReceiverElement, StateReceiverPropertyMap } from './state-receiver';
+//# sourceMappingURL=index.d.ts.map