@flowplayer/player 3.10.3 → 3.10.4-rc.2

package/util/loader.d.ts

@@ -1,9 +1,329 @@
-import { PluginCtor } from "../types/plugin";
-/**
- * adds support for asynchronous plugin loading`
- * issue/127
- */
-export declare function define(root: any, plugin: PluginCtor): PluginCtor;
-export declare function isESM(): boolean;
-export declare function root(): {};
-export declare function modules(): any;
+import type { MediaKeyFunc } from 'hls.js';
+
+declare type AnyPlugin = Plugin_2 | Loader;
+
+declare type BitOpts = number;
+
+declare type Component = {
+    onrender?: (config: Config, root: PlayerRoot, player: Player) => void;
+    onremove?: (config: Config, root: PlayerRoot, player: Player) => void;
+};
+
+declare interface Components {
+    render(key: string, args: any[]): void;
+    remove(key: string, args: any[]): void;
+    put(key: string, args: Component): void;
+}
+
+declare interface Config {
+    src?: UnsafeSource;
+    preload?: "none" | "metadata" | "auto";
+    controls?: boolean;
+    lang?: string;
+    start_time?: number;
+    autopause?: boolean;
+    rewind?: boolean;
+    loop?: boolean;
+    seamless?: boolean;
+    retry?: boolean;
+    autoplay?: BitOpts;
+    start_quality?: BitOpts;
+    live?: boolean;
+    poster?: string;
+    disabled?: boolean;
+    muted?: boolean;
+    /**
+     * is src handled by one of plugins loaders
+     */
+    is_native?: boolean;
+    /**
+     * bitflags for UI options
+     */
+    ui?: BitOpts;
+    /**
+     * your user access token
+     */
+    token?: string;
+    /**
+     * manually configured duration for pre-rendering usually
+     */
+    duration?: number;
+    /**
+     * can the content be seeked to any position
+     */
+    seekable?: boolean;
+    multiplay?: boolean;
+    ratio?: number | string;
+    logo?: string;
+    logo_href?: string;
+    logo_alt_text?: string;
+    title?: string;
+    description?: string;
+    /**
+     * the number of seconds to have in the buffer before dvr is activated
+     */
+    seconds_to_dvr?: number;
+}
+
+declare namespace Configs {
+    export {
+        BitOpts,
+        FlowplayerCustomElementRegistry,
+        Config,
+        CustomConfig,
+        PluginConfig
+    }
+}
+
+declare type CustomConfig<T> = Config & T;
+
+/**
+ * adds support for asynchronous plugin loading`
+ * issue/127
+ */
+export declare function define(root: any, plugin: PluginCtor): PluginCtor;
+
+declare type DeviceId = string;
+
+declare type DRM_KEYSYSTEM = "com.widevine.alpha" | "com.microsoft.playready" | "org.w3.clearkey" | "com.apple.fps.1_0";
+
+declare type DRMConfiguration = {
+    license_server: string;
+    http_headers?: Record<string, string>;
+    certificate?: string;
+    vendor?: string | DRMVendorImplementation;
+    request_media_key_system_access_function?: MediaKeyFunc;
+    query_params?: Record<string, string>;
+};
+
+declare type DRMSourceConfiguration = {
+    [keysystem in DRM_KEYSYSTEM]?: DRMConfiguration;
+};
+
+declare type DRMVendorImplementation = {
+    fairplay_fetch_certificate: (url: string, cb: (certificate_data: Uint8Array) => void) => void;
+    fairplay_request_license: (url: string, params: {
+        message: any;
+        assetId: string;
+    }, cb: (license_data: Uint8Array) => void) => void;
+};
+
+declare namespace Flowplayer {
+    type SourceStr = Sources.SourceStr;
+    type DRM_KEYSYSTEM = Sources.DRM_KEYSYSTEM;
+    type SourceObj = Sources.SourceObj;
+    type DRMSourceConfiguration = Sources.DRMSourceConfiguration;
+    type SourceWith<T> = Sources.SourceWith<T>;
+    type UnsafeSource = Sources.UnsafeSource;
+    type SourceList = Sources.SourceList;
+    type DRMConfiguration = Sources.DRMConfiguration;
+    type DRMVendorImplementation = Sources.DRMVendorImplementation;
+    type BitOpts = Configs.BitOpts;
+    type FlowplayerCustomElementRegistry = Configs.FlowplayerCustomElementRegistry;
+    interface Config extends Configs.Config {
+    }
+    type CustomConfig<T> = Configs.CustomConfig<T>;
+    type PluginConfig<T> = Configs.PluginConfig<T>;
+    interface VideoTrack extends Players.VideoTrack {
+    }
+    interface FPEvent<T> extends Players.FPEvent<T> {
+    }
+    type DeviceId = Players.DeviceId;
+    type JSONPlayer = Players.JSONPlayer;
+    type PlayerRoot = Players.PlayerRoot;
+    interface Player extends Players.Player {
+    }
+    type PlayerState = Players.PlayerState;
+    interface FlowplayerUMD extends FlowplayerUMDs.FlowplayerUMD {
+    }
+    interface Components extends FlowplayerUMDs.Components {
+    }
+    type Component = FlowplayerUMDs.Component;
+    enum AutoplayOpts {
+        OFF,
+        ON,
+        AUDIO_REQUIRED
+    }
+    enum QualityOpts {
+        LOW,
+        MEDIUM,
+        HIGH
+    }
+}
+
+declare type FlowplayerCustomElementRegistry = Map<string, string>;
+
+declare interface FlowplayerUMD {
+    (selector: string, config?: Config): Player;
+    <T>(selector: string, config?: CustomConfig<T>): Player;
+    (element: HTMLElement, config?: Config): Player;
+    <T>(element: HTMLElement, config?: CustomConfig<T>): Player;
+    (...plugins: PluginCtor[]): void;
+    instances: Player[];
+    extensions: PluginCtor[];
+    events: Record<string, string>;
+    ads?: {
+        events: Record<string, string>;
+    };
+    states: Record<string, string>;
+    quality: typeof Flowplayer.QualityOpts;
+    commit: string;
+    version: string;
+    customElements: FlowplayerCustomElementRegistry;
+    defaultElements: Record<string, string>;
+    components: Components;
+    support: any;
+    autoplay: typeof Flowplayer.AutoplayOpts;
+    jwt: any;
+    loaders: any;
+}
+
+declare namespace FlowplayerUMDs {
+    export {
+        FlowplayerUMD,
+        Components,
+        Component
+    }
+}
+
+declare interface FPEvent<T> extends CustomEvent<T> {
+    /**
+     * @deprecated
+     the data attribute has been migrated to details to match the CustomEvent spec
+     more info: https://developer.mozilla.org/en-US/docs/Web/API/CustomEvent/CustomEvent
+     */
+    data?: T;
+}
+
+export declare function isESM(): boolean;
+
+declare type JSONPlayer = any;
+
+declare type KeyValue = Record<string, any>;
+
+declare interface Loader extends Plugin_2 {
+    onload<T = KeyValue>(config: PluginConfig<T>, root: PlayerRoot, video: Player, src?: SourceObj): void;
+    wants<S = SourceObj, T = KeyValue>(srcString: SourceStr, srcObj: S, config: PluginConfig<T>): boolean;
+    wants<S = KeyValue, T = KeyValue>(srcString: SourceStr, srcObj: SourceWith<S>, config: PluginConfig<T>): boolean;
+}
+
+export declare function modules(): any;
+
+declare interface Player extends HTMLVideoElement {
+    renderPlugin: (pluginContainer: HTMLElement) => void;
+    toggleDisable: (flag: boolean) => void;
+    original_src: string;
+    root: PlayerRoot;
+    playerState: Record<string, boolean>;
+    reaper: Map<string, any> | 0;
+    hasState(state: PlayerState): boolean;
+    transitionState(to: PlayerState, from: PlayerState, timer?: number): void;
+    togglePlay(on?: boolean): Promise<void>;
+    toggleFullScreen(on?: boolean, state_only?: boolean): void;
+    toggleMute(on?: boolean): void;
+    destroy(): void;
+    render(): void;
+    render(component: string, args: any[]): void;
+    createComponents(...args: string[]): HTMLElement[];
+    setOpts(config: Config): void;
+    setSrc(sources: UnsafeSource): Player;
+    on<T>(event: string | string[], handler: (e: FPEvent<T>) => void): Player;
+    once<T>(event: string, handler: (e: FPEvent<T>) => void): Player;
+    off<T>(event: string, handler: (e: FPEvent<T>) => void): Player;
+    poll<T>(event: string, data?: T): FPEvent<T>;
+    emit<T>(event: string, data?: T): Player;
+    setAttrs(attrs: Config): Player;
+    opt<T>(key: string, fallback?: T): T;
+    enqueueSeek(offset: number): any;
+    setState(state: string, flag: boolean): Player;
+    toJSON(): JSONPlayer;
+    i18n(k: string, fallback?: string): string;
+    deviceId(): DeviceId;
+    live_state: {
+        dvr?: boolean;
+        dvr_window?: number;
+    };
+    opts: Config;
+    plugins: Array<Plugin_2 | Loader>;
+    dvr_offset?: number;
+    message?: {
+        events: Record<string, string>;
+    };
+    disabled: boolean;
+    started?: boolean;
+    token: string;
+    tracks?: VideoTrack[];
+    _customElements: FlowplayerCustomElementRegistry;
+    _storage: Storage;
+}
+
+declare type PlayerRoot = HTMLElement & {
+    prevWidth?: number;
+};
+
+declare namespace Players {
+    export {
+        VideoTrack,
+        PlayerState,
+        FPEvent,
+        DeviceId,
+        JSONPlayer,
+        PlayerRoot,
+        Player
+    }
+}
+
+declare type PlayerState = string;
+
+declare interface Plugin_2 {
+    /**
+     * a plugin must always implement the init method so a player instance knows how to initialize it
+     */
+    init<T>(config: PluginConfig<T>, container: PlayerRoot, player: Player): void;
+    init(config: Config, container: PlayerRoot, player: Player): void;
+}
+
+declare type PluginConfig<T> = Config & T;
+
+declare interface PluginCtor {
+    new (umd: FlowplayerUMD, player: Player): AnyPlugin;
+}
+
+export declare function root(): {};
+
+declare type SourceList = Array<SourceObj>;
+
+declare type SourceObj = {
+    src?: SourceStr;
+    type?: string;
+    drm?: DRMSourceConfiguration;
+};
+
+declare namespace Sources {
+    export {
+        SourceStr,
+        DRM_KEYSYSTEM,
+        SourceObj,
+        DRMSourceConfiguration,
+        SourceWith,
+        UnsafeSource,
+        SourceList,
+        DRMConfiguration,
+        DRMVendorImplementation
+    }
+}
+
+declare type SourceStr = string;
+
+declare type SourceWith<T> = SourceObj & T;
+
+declare type UnsafeSource = SourceStr | SourceObj | Array<SourceStr | SourceObj>;
+
+declare interface VideoTrack {
+    name: string;
+    data: any;
+    default: boolean;
+    selected: boolean;
+}
+
+export { }

package/plugin.d.ts

@@ -1,31 +0,0 @@
-import { Config
-       , Player
-       , PlayerRoot
-       , SourceObj
-       , SourceStr
-       , FlowplayerUMD
-       , PluginConfig,
-       SourceWith
-       } from "."
-
-export interface Plugin {
-  /**
-   * a plugin must always implement the init method so a player instance knows how to initialize it
-   */
-  init<T> (config : PluginConfig<T>, container : PlayerRoot, player : Player): void;
-  init (config : Config, container : PlayerRoot, player : Player): void;
-}
-
-export interface Loader extends Plugin {
-  onload<T = Record<string, any>> (config : PluginConfig<T>, root : PlayerRoot, video : Player, src? : SourceObj): void;
-  wants<S = SourceObj, T = Record<string, any>> (srcString : SourceStr, srcObj : S, config : PluginConfig<T>): boolean;
-  wants<S = Record<string, any>, T = Record<string, any>> (srcString : SourceStr, srcObj : SourceWith<S>, config : PluginConfig<T>): boolean;
-}
-
-export interface PluginCtor {
-  new (umd : FlowplayerUMD, player : Player): AnyPlugin
-}
-
-export type AnyPlugin =
-  | Plugin
-  | Loader