@videts/vide 0.7.4 → 0.9.2

package/dist/types-BsEF8iWC.d.ts

@@ -0,0 +1,316 @@
+type MediaElement = HTMLVideoElement | HTMLAudioElement;
+type PlayerState = "idle" | "loading" | "ready" | "playing" | "paused" | "buffering" | "ad:loading" | "ad:playing" | "ad:paused" | "ended" | "error";
+type AdQuartile = "start" | "firstQuartile" | "midpoint" | "thirdQuartile" | "complete";
+interface PlayerEventMap {
+    statechange: {
+        from: PlayerState;
+        to: PlayerState;
+    };
+    play: undefined;
+    pause: undefined;
+    ended: undefined;
+    timeupdate: {
+        currentTime: number;
+        duration: number;
+    };
+    livestatechange: {
+        isLive: boolean;
+    };
+    error: {
+        code: number;
+        message: string;
+        source: string;
+        recoverable?: boolean | undefined;
+        retryCount?: number | undefined;
+    };
+    "ad:companions": {
+        adId: string;
+        required: "all" | "any" | "none";
+        companions: {
+            width: number;
+            height: number;
+            id?: string | undefined;
+            assetWidth?: number | undefined;
+            assetHeight?: number | undefined;
+            expandedWidth?: number | undefined;
+            expandedHeight?: number | undefined;
+            pxratio?: number | undefined;
+            renderingMode?: "default" | "end-card" | "concurrent" | undefined;
+            resources: Array<{
+                type: "static";
+                url: string;
+                creativeType: string;
+            } | {
+                type: "iframe";
+                url: string;
+            } | {
+                type: "html";
+                content: string;
+            }>;
+            clickThrough?: string | undefined;
+            clickTracking: string[];
+            trackingEvents: {
+                creativeView: string[];
+            };
+            altText?: string | undefined;
+            adParameters?: string | undefined;
+        }[];
+    };
+    "ad:nonlinears": {
+        adId: string;
+        nonLinears: {
+            width: number;
+            height: number;
+            id?: string | undefined;
+            expandedWidth?: number | undefined;
+            expandedHeight?: number | undefined;
+            scalable?: boolean | undefined;
+            maintainAspectRatio?: boolean | undefined;
+            minSuggestedDuration?: number | undefined;
+            apiFramework?: string | undefined;
+            resources: Array<{
+                type: "static";
+                url: string;
+                creativeType: string;
+            } | {
+                type: "iframe";
+                url: string;
+            } | {
+                type: "html";
+                content: string;
+            }>;
+            clickThrough?: string | undefined;
+            clickTracking: string[];
+            adParameters?: string | undefined;
+        }[];
+        trackingEvents: Record<string, string[]>;
+    };
+    "ad:start": {
+        adId: string;
+        clickThrough?: string | undefined;
+        skipOffset?: number | undefined;
+        duration?: number | undefined;
+        adTitle?: string | undefined;
+    };
+    "ad:end": {
+        adId: string;
+    };
+    "ad:skip": {
+        adId: string;
+    };
+    "ad:click": {
+        clickThrough: string | undefined;
+        clickTracking: string[];
+    };
+    "ad:error": {
+        error: Error;
+        source: string;
+        /** VAST 4.2 error code. Undefined for non-VAST errors. */
+        vastErrorCode?: number | undefined;
+    };
+    "ad:impression": {
+        adId: string;
+    };
+    "ad:loaded": {
+        adId: string;
+    };
+    "ad:quartile": {
+        adId: string;
+        quartile: AdQuartile;
+    };
+    "ad:mute": {
+        adId: string;
+    };
+    "ad:unmute": {
+        adId: string;
+    };
+    "ad:volumeChange": {
+        adId: string;
+        volume: number;
+    };
+    "ad:fullscreen": {
+        adId: string;
+        fullscreen: boolean;
+    };
+    "ad:breakStart": {
+        breakId: string | undefined;
+    };
+    "ad:breakEnd": {
+        breakId: string | undefined;
+    };
+    "ad:pod:start": {
+        ads: {
+            id: string;
+            sequence?: number | undefined;
+        }[];
+        total: number;
+    };
+    "ad:pod:end": {
+        completed: number;
+        skipped: number;
+        failed: number;
+    };
+    "ad:pod:adstart": {
+        ad: {
+            id: string;
+            sequence?: number | undefined;
+        };
+        index: number;
+        total: number;
+    };
+    "ad:pod:adend": {
+        ad: {
+            id: string;
+            sequence?: number | undefined;
+        };
+        index: number;
+        total: number;
+    };
+    qualitiesavailable: {
+        qualities: QualityLevel[];
+    };
+    qualitychange: {
+        from: QualityLevel | null;
+        to: QualityLevel;
+    };
+    texttrackchange: {
+        track: VideTextTrack | null;
+    };
+    texttracksavailable: {
+        tracks: VideTextTrack[];
+    };
+    cuechange: {
+        cues: VideCue[];
+    };
+    destroy: undefined;
+}
+type PlayerEvent = keyof PlayerEventMap;
+/** Ad metadata exposed by framework `useAdState` hooks. */
+interface AdMeta {
+    adId: string;
+    clickThrough: string | undefined;
+    skipOffset: number | undefined;
+    duration: number | undefined;
+    adTitle: string | undefined;
+    adStartTime: number;
+}
+interface RecoveryConfig {
+    maxRetries: number;
+    retryDelay: number;
+    backoffMultiplier: number;
+}
+type EventHandler<T> = (data: T) => void;
+/** Native media event names not already covered by PlayerEventMap. */
+type NativeMediaEvent = Exclude<keyof HTMLMediaElementEventMap, keyof PlayerEventMap>;
+interface EventBus {
+    on<K extends PlayerEvent>(event: K, handler: EventHandler<PlayerEventMap[K]>): void;
+    on<K extends NativeMediaEvent>(event: K, handler: (ev: HTMLMediaElementEventMap[K]) => void): void;
+    on(event: string, handler: (...args: any[]) => void): void;
+    off<K extends PlayerEvent>(event: K, handler: EventHandler<PlayerEventMap[K]>): void;
+    off<K extends NativeMediaEvent>(event: K, handler: (ev: HTMLMediaElementEventMap[K]) => void): void;
+    off(event: string, handler: (...args: any[]) => void): void;
+    emit<K extends PlayerEvent>(event: K, data: PlayerEventMap[K]): void;
+    once<K extends PlayerEvent>(event: K, handler: EventHandler<PlayerEventMap[K]>): void;
+    once<K extends NativeMediaEvent>(event: K, handler: (ev: HTMLMediaElementEventMap[K]) => void): void;
+    once(event: string, handler: (...args: any[]) => void): void;
+}
+interface SeekableRange {
+    start: number;
+    end: number;
+}
+interface QualityLevel {
+    id: number;
+    width: number;
+    height: number;
+    bitrate: number;
+    label: string;
+}
+interface VideTextTrack {
+    id: number;
+    label: string;
+    language: string;
+    kind: "subtitles" | "captions" | "descriptions" | "chapters" | "metadata";
+    active: boolean;
+}
+interface VideCue {
+    startTime: number;
+    endTime: number;
+    text: string;
+}
+interface SourceHandler {
+    /** Whether this handler can process the given URL/type. */
+    canHandle(url: string, type?: string): boolean;
+    /** Load the source into the media element. */
+    load(url: string, mediaElement: MediaElement): void;
+    /** Unload the source and clean up. */
+    unload(mediaElement: MediaElement): void;
+}
+interface Plugin {
+    name: string;
+    setup(player: Player): (() => void) | undefined;
+}
+interface Player extends EventBus {
+    readonly el: MediaElement;
+    readonly state: PlayerState;
+    play(): Promise<void>;
+    pause(): void;
+    currentTime: number;
+    duration: number;
+    volume: number;
+    muted: boolean;
+    playbackRate: number;
+    readonly paused: boolean;
+    readonly ended: boolean;
+    readonly readyState: number;
+    readonly buffered: TimeRanges;
+    readonly seekable: TimeRanges;
+    readonly seeking: boolean;
+    readonly isLive: boolean;
+    readonly seekableRange: SeekableRange | null;
+    readonly qualities: QualityLevel[];
+    readonly currentQuality: QualityLevel | null;
+    setQuality(id: number): void;
+    readonly isAutoQuality: boolean;
+    readonly isAudio: boolean;
+    readonly textTracks: TextTrackList;
+    getTextTracks(): VideTextTrack[];
+    getActiveTextTrack(): VideTextTrack | null;
+    readonly activeCues: VideCue[];
+    setTextTrack(id: number): void;
+    addTextTrack(options: {
+        src: string;
+        label: string;
+        language: string;
+        kind?: "subtitles" | "captions";
+        default?: boolean;
+    }): void;
+    readonly videoWidth: number;
+    readonly videoHeight: number;
+    readonly networkState: number;
+    loop: boolean;
+    autoplay: boolean;
+    poster: string;
+    preload: "" | "none" | "metadata" | "auto";
+    defaultPlaybackRate: number;
+    defaultMuted: boolean;
+    crossOrigin: string | null;
+    controls: boolean;
+    /** Web-standard addEventListener, delegates to the underlying media element. */
+    addEventListener<K extends keyof HTMLMediaElementEventMap>(type: K, listener: (ev: HTMLMediaElementEventMap[K]) => void, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    /** Web-standard removeEventListener, delegates to the underlying media element. */
+    removeEventListener<K extends keyof HTMLMediaElementEventMap>(type: K, listener: (ev: HTMLMediaElementEventMap[K]) => void, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+    /** Current media source URL. Setting triggers SourceHandler lookup. */
+    src: string;
+    /** Register a handler for custom source types (e.g., HLS, DASH). */
+    registerSourceHandler(handler: SourceHandler): void;
+    use(plugin: Plugin): void;
+    destroy(): void;
+    /** Store data for cross-plugin communication. */
+    setPluginData(key: string, data: unknown): void;
+    /** Retrieve data stored by another plugin. Returns undefined if not set. */
+    getPluginData(key: string): unknown;
+}
+
+export type { AdMeta as A, EventBus as E, MediaElement as M, Player as P, QualityLevel as Q, RecoveryConfig as R, SeekableRange as S, VideCue as V, AdQuartile as a, EventHandler as b, PlayerEvent as c, PlayerEventMap as d, PlayerState as e, Plugin as f, SourceHandler as g, VideTextTrack as h };

package/dist/types-C1_eVsFF.d.ts

@@ -0,0 +1,49 @@
+import { c as VastAd, A as AdPlugin } from './types-COeag8fU.js';
+
+interface VmapResponse {
+    version: string;
+    adBreaks: AdBreak[];
+}
+interface AdBreakTrackingEvents {
+    breakStart: string[];
+    breakEnd: string[];
+    error: string[];
+}
+interface AdBreak {
+    timeOffset: AdBreakTimeOffset;
+    breakType: "linear" | "nonlinear" | "display";
+    breakId?: string | undefined;
+    adSource: AdSource | null;
+    trackingEvents: AdBreakTrackingEvents;
+}
+type AdBreakTimeOffset = {
+    type: "start";
+} | {
+    type: "end";
+} | {
+    type: "time";
+    seconds: number;
+} | {
+    type: "percentage";
+    pct: number;
+};
+interface AdSource {
+    id?: string | undefined;
+    allowMultipleAds?: boolean | undefined;
+    followRedirects?: boolean | undefined;
+    vastUrl?: string | undefined;
+    vastData?: string | undefined;
+}
+
+interface VmapPluginOptions {
+    url: string;
+    timeout?: number | undefined;
+    vastOptions?: {
+        timeout?: number | undefined;
+        maxDepth?: number | undefined;
+    };
+    /** Create per-ad plugins. Called once per ad with the parsed VastAd. */
+    adPlugins?: ((ad: VastAd) => AdPlugin[]) | undefined;
+}
+
+export type { AdBreak as A, VmapResponse as V, VmapPluginOptions as a, AdBreakTimeOffset as b, AdBreakTrackingEvents as c, AdSource as d };

package/dist/types-C6XFF6w_.d.ts

@@ -0,0 +1,30 @@
+/** Widevine DRM configuration. */
+interface WidevineConfig {
+    licenseUrl: string;
+    headers?: Record<string, string> | undefined;
+    prepareLicenseRequest?: ((payload: Uint8Array) => Uint8Array | Promise<Uint8Array>) | undefined;
+    processLicenseResponse?: ((response: Uint8Array) => Uint8Array | Promise<Uint8Array>) | undefined;
+}
+/** FairPlay DRM configuration. */
+interface FairPlayConfig {
+    licenseUrl: string;
+    certificateUrl: string;
+    headers?: Record<string, string> | undefined;
+    prepareLicenseRequest?: ((payload: Uint8Array) => Uint8Array | Promise<Uint8Array>) | undefined;
+    processLicenseResponse?: ((response: Uint8Array) => Uint8Array | Promise<Uint8Array>) | undefined;
+}
+/** Options for the DRM plugin. */
+interface DrmPluginOptions {
+    widevine?: WidevineConfig | undefined;
+    fairplay?: FairPlayConfig | undefined;
+}
+/** Key system identifier string. */
+type KeySystem = "com.widevine.alpha" | "com.apple.fps.1_0";
+/** Resolved DRM configuration stored via setPluginData("drm"). */
+interface ResolvedDrmConfig {
+    keySystem: KeySystem;
+    hlsConfig: Record<string, unknown>;
+    dashConfig: Record<string, unknown>;
+}
+
+export type { DrmPluginOptions as D, FairPlayConfig as F, KeySystem as K, ResolvedDrmConfig as R, WidevineConfig as W };

package/dist/types-COeag8fU.d.ts

@@ -0,0 +1,173 @@
+import { P as Player } from './types-BsEF8iWC.js';
+
+interface VastResponse {
+    version: string;
+    ads: VastAd[];
+    errors: string[];
+}
+interface VastAd {
+    id: string;
+    sequence?: number | undefined;
+    adSystem: string;
+    adTitle: string;
+    impressions: string[];
+    creatives: VastCreative[];
+    errors: string[];
+    verifications?: AdVerification[] | undefined;
+    categories?: AdCategory[] | undefined;
+    extensions?: VastExtension[] | undefined;
+    viewableImpression?: VastViewableImpression | undefined;
+}
+interface AdVerification {
+    vendor: string;
+    resourceUrl: string;
+    apiFramework?: string | undefined;
+    parameters?: string | undefined;
+}
+interface AdCategory {
+    authority: string;
+    value: string;
+}
+interface VastExtension {
+    type: string;
+    content: string;
+}
+interface VastViewableImpression {
+    viewable: string[];
+    notViewable: string[];
+    viewUndetermined: string[];
+}
+interface VastCreative {
+    id?: string | undefined;
+    sequence?: number | undefined;
+    linear: VastLinear | null;
+    companionAds?: VastCompanionAds | undefined;
+    nonLinearAds?: VastNonLinearAds | undefined;
+}
+interface VastLinear {
+    duration: number;
+    skipOffset?: number | undefined;
+    mediaFiles: VastMediaFile[];
+    interactiveCreativeFiles: InteractiveCreativeFile[];
+    trackingEvents: VastTrackingEvents;
+    clickThrough?: string | undefined;
+    clickTracking: string[];
+}
+interface VastMediaFile {
+    url: string;
+    mimeType: string;
+    width: number;
+    height: number;
+    bitrate?: number | undefined;
+    delivery: "progressive" | "streaming";
+}
+interface InteractiveCreativeFile {
+    url: string;
+    apiFramework: string;
+    variableDuration?: boolean | undefined;
+}
+interface VastProgressEvent {
+    offset: number;
+    url: string;
+}
+interface VastTrackingEvents {
+    start: string[];
+    firstQuartile: string[];
+    midpoint: string[];
+    thirdQuartile: string[];
+    complete: string[];
+    pause: string[];
+    resume: string[];
+    skip: string[];
+    loaded: string[];
+    mute: string[];
+    unmute: string[];
+    rewind: string[];
+    playerExpand: string[];
+    playerCollapse: string[];
+    closeLinear: string[];
+    notUsed: string[];
+    otherAdInteraction: string[];
+    creativeView: string[];
+    progress: VastProgressEvent[];
+}
+type CompanionRequired = "all" | "any" | "none";
+type CompanionRenderingMode = "default" | "end-card" | "concurrent";
+interface CompanionTrackingEvents {
+    creativeView: string[];
+}
+interface CompanionStaticResource {
+    type: "static";
+    url: string;
+    creativeType: string;
+}
+interface CompanionIFrameResource {
+    type: "iframe";
+    url: string;
+}
+interface CompanionHTMLResource {
+    type: "html";
+    content: string;
+}
+type CompanionResource = CompanionStaticResource | CompanionIFrameResource | CompanionHTMLResource;
+interface VastCompanionAd {
+    width: number;
+    height: number;
+    id?: string | undefined;
+    assetWidth?: number | undefined;
+    assetHeight?: number | undefined;
+    expandedWidth?: number | undefined;
+    expandedHeight?: number | undefined;
+    apiFramework?: string | undefined;
+    adSlotId?: string | undefined;
+    pxratio?: number | undefined;
+    renderingMode?: CompanionRenderingMode | undefined;
+    resources: CompanionResource[];
+    clickThrough?: string | undefined;
+    clickTracking: string[];
+    trackingEvents: CompanionTrackingEvents;
+    altText?: string | undefined;
+    adParameters?: string | undefined;
+}
+interface VastCompanionAds {
+    required: CompanionRequired;
+    companions: VastCompanionAd[];
+}
+interface NonLinearAd {
+    width: number;
+    height: number;
+    id?: string | undefined;
+    expandedWidth?: number | undefined;
+    expandedHeight?: number | undefined;
+    scalable?: boolean | undefined;
+    maintainAspectRatio?: boolean | undefined;
+    /** Minimum suggested display time in seconds, parsed from HH:MM:SS */
+    minSuggestedDuration?: number | undefined;
+    apiFramework?: string | undefined;
+    resources: CompanionResource[];
+    clickThrough?: string | undefined;
+    clickTracking: string[];
+    adParameters?: string | undefined;
+}
+interface VastNonLinearAds {
+    trackingEvents: Record<string, string[]>;
+    nonLinears: NonLinearAd[];
+}
+/** Plugin scoped to a single ad. Created per-ad, cleaned up on ad end. */
+interface AdPlugin {
+    name: string;
+    setup(player: Player, ad: VastAd): (() => void) | undefined;
+}
+interface VastPluginOptions {
+    tagUrl: string;
+    timeout?: number | undefined;
+    allowSkip?: boolean | undefined;
+    /** Create per-ad plugins. Called once per ad with the parsed VastAd. */
+    adPlugins?: ((ad: VastAd) => AdPlugin[]) | undefined;
+}
+interface ResolveOptions {
+    timeout?: number | undefined;
+    maxDepth?: number | undefined;
+}
+
+export type { AdPlugin as A, CompanionHTMLResource as C, NonLinearAd as N, ResolveOptions as R, VastResponse as V, VastCompanionAd as a, VastNonLinearAds as b, VastAd as c, VastLinear as d, VastPluginOptions as e, AdCategory as f, AdVerification as g, CompanionIFrameResource as h, CompanionRenderingMode as i, CompanionRequired as j, CompanionResource as k, CompanionStaticResource as l, CompanionTrackingEvents as m, VastCompanionAds as n, VastExtension as o, VastProgressEvent as p, VastViewableImpression as q };

package/dist/types-CwjR99DL.d.ts

@@ -0,0 +1,10 @@
+import { R as RecoveryConfig } from './types-BsEF8iWC.js';
+
+interface HlsPluginOptions {
+    /** Configuration passed directly to the hls.js constructor. */
+    hlsConfig?: Record<string, unknown> | undefined;
+    /** Error recovery settings. `false` to disable. Defaults to enabled (3 retries, 3s delay, 2x backoff). */
+    recovery?: Partial<RecoveryConfig> | false | undefined;
+}
+
+export type { HlsPluginOptions as H };

package/dist/types-DsixuzNX.d.ts

@@ -0,0 +1,52 @@
+/** VAST-equivalent tracking URL map for SSAI ad breaks. */
+interface AdTrackingMap {
+    impression?: string[];
+    start?: string[];
+    firstQuartile?: string[];
+    midpoint?: string[];
+    thirdQuartile?: string[];
+    complete?: string[];
+    pause?: string[];
+    resume?: string[];
+    skip?: string[];
+}
+/** Parsed ad break metadata from stream signals. */
+interface AdBreakMetadata {
+    id: string;
+    /** Absolute start time in seconds relative to stream timeline. */
+    startTime: number;
+    /** Duration of the ad break in seconds. */
+    duration: number;
+    /** Timing-specific tracking URLs. */
+    tracking?: AdTrackingMap;
+    clickThrough?: string;
+    customData?: Record<string, string>;
+}
+/** Discriminated union of raw metadata from different stream sources. */
+type RawMetadata = {
+    source: "daterange";
+    attributes: Record<string, string>;
+} | {
+    source: "id3";
+    samples: Array<{
+        type: string;
+        data: Uint8Array;
+    }>;
+} | {
+    source: "eventstream";
+    schemeIdUri: string;
+    value: string;
+    startTime: number;
+    duration: number;
+    messageData?: string | undefined;
+};
+/** Custom parser: receives raw metadata, returns zero or more ad breaks. */
+type MetadataParser = (raw: RawMetadata) => AdBreakMetadata[];
+interface SsaiPluginOptions {
+    /** Custom metadata parser. Overrides default auto-detection. */
+    parser?: MetadataParser;
+    /** Tolerance in seconds for time-based ad break matching. Default: 0.5. */
+    tolerance?: number;
+}
+
+export type { AdBreakMetadata as A, MetadataParser as M, RawMetadata as R, SsaiPluginOptions as S, AdTrackingMap as a };

package/dist/types-DzY1cmXC.d.ts

@@ -0,0 +1,10 @@
+import { R as RecoveryConfig } from './types-BsEF8iWC.js';
+
+interface DashPluginOptions {
+    /** dash.js MediaPlayerSettingClass — passed to updateSettings(). */
+    dashConfig?: Record<string, unknown> | undefined;
+    /** Error recovery settings. `false` to disable. Defaults to enabled (3 retries, 3s delay, 2x backoff). */
+    recovery?: Partial<RecoveryConfig> | false | undefined;
+}
+
+export type { DashPluginOptions as D };

package/dist/types-SuT99_Z3.d.ts

@@ -0,0 +1,40 @@
+import { P as Player } from './types-BsEF8iWC.js';
+
+/** A single UI component that can be independently mounted and connected. */
+interface UIComponent {
+    /** Create DOM elements and append them to the container. */
+    mount(container: HTMLElement): void;
+    /** Subscribe to player events and start reacting. */
+    connect(player: Player): void;
+    /** Remove DOM elements and unsubscribe from all events. */
+    destroy(): void;
+}
+/** Shared mutable state for ad UI components. Set by uiAdPlugin, read by ad components. */
+interface AdUIState {
+    adId: string;
+    skipOffset: number | undefined;
+    clickThrough: string | undefined;
+    duration: number;
+    adTitle: string | undefined;
+}
+/** Mutable holder for AdUIState, shared between ad-plugin and ad UI components. */
+interface AdUIStateRef {
+    current: AdUIState | null;
+    set(state: AdUIState): void;
+    clear(): void;
+}
+/** Component names that can be excluded from the ui() convenience plugin. */
+type UIComponentName = "play" | "progress" | "time" | "volume" | "fullscreen" | "loader" | "error" | "bigplay" | "poster" | "ad-countdown" | "ad-skip" | "ad-overlay" | "ad-label" | "ad-learn-more" | "keyboard" | "clickplay" | "autohide";
+/** Options for the ui() convenience plugin. */
+interface UiPluginOptions {
+    /** Container element to mount UI controls into. */
+    container: HTMLElement;
+    /** Components to exclude (default: `ad-overlay`). */
+    exclude?: UIComponentName[] | undefined;
+    /** Components to opt-in (overrides default exclusions like `ad-overlay`). */
+    include?: UIComponentName[] | undefined;
+    /** Poster image URL. */
+    poster?: string | undefined;
+}
+
+export type { AdUIStateRef as A, UIComponent as U, UIComponentName as a, UiPluginOptions as b, AdUIState as c };