@flowplayer/player 3.11.1 → 3.11.2-rc.0

package/plugins/fas.d.ts

@@ -0,0 +1,364 @@
+import type { FRAMERATE } from 'smpte-timecode';
+import type { MediaKeyFunc } from 'hls.js';
+
+declare type AnyPlugin<PluginOwnConfig extends KeyValue> = Plugin_2<PluginOwnConfig> | Loader<PluginOwnConfig>;
+
+declare type ArrayToIntersection<T extends Array<unknown>> = T extends [infer Current, ...infer Remaining] ? Current & ArrayToIntersection<Remaining> : unknown;
+
+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 ConfigWith<T> = Configs.Config & T;
+
+declare type CustomConfig<T> = Config & T;
+
+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 class FAS implements Plugin_2 {
+    readonly player: Player;
+    frame_rate: FRAMERATE;
+    frame_offset: number;
+    constructor(umd: FlowplayerUMD, player: Player);
+    init(_config: FASConfig, _root: PlayerRoot, video: PlayerWith<{
+        hls?: any;
+        fas?: FAS;
+    }>): void;
+    current_frame(): number;
+    seek_to(timecode_or_frame: number): void;
+    current_timecode(): string;
+    jump(frames: number): void;
+}
+export default FAS;
+
+declare type FASAttrs = {
+    frame_rate?: FRAMERATE;
+    frame_offset?: number;
+};
+
+declare type FASConfig = ConfigWith<{
+    fas?: FASAttrs;
+}>;
+
+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 extends FlowplayerUMDBase {
+    (selector: string, config?: Config): Player;
+    (element: HTMLElement, config?: Config): Player;
+    <T>(selector: string, config?: CustomConfig<T>): Player;
+    <T>(element: HTMLElement, config?: CustomConfig<T>): Player;
+    <PluginCtors extends PluginCtor[]>(...plugins: PluginCtors): FlowplayerUMDWithPlugins<CustomConfig<MergeConfigs<PluginCtors>>>;
+}
+
+declare interface FlowplayerUMDBase {
+    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,
+        FlowplayerUMDWithPlugins,
+        Components,
+        Component
+    }
+}
+
+declare interface FlowplayerUMDWithPlugins<ConfigWithPlugins extends Config = Config> extends FlowplayerUMDBase {
+    (selector: string, config?: ConfigWithPlugins): Player;
+    (element: HTMLElement, config?: ConfigWithPlugins): Player;
+}
+
+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;
+}
+
+declare type JSONPlayer = any;
+
+declare type KeyValue = Record<string, any>;
+
+declare interface Loader<PluginOwnConfig extends KeyValue = KeyValue> extends Plugin_2<PluginOwnConfig> {
+    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;
+}
+
+declare type MapToConfigs<Arr extends PluginCtor[]> = {
+    [PluginType in keyof Arr]: Arr[PluginType] extends PluginCtor<infer ConfigType> ? ConfigType : never;
+};
+
+declare type MergeConfigs<Arr extends PluginCtor[]> = ArrayToIntersection<MapToConfigs<Arr>>;
+
+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 type PlayerWith<T> = Players.Player & T;
+
+declare interface Plugin_2<PluginOwnConfig extends KeyValue = KeyValue> {
+    /**
+     * 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: PluginConfig<PluginOwnConfig>, container: PlayerRoot, player: Player): void;
+}
+
+declare type PluginConfig<T> = Config & T;
+
+declare interface PluginCtor<PluginOwnConfig extends KeyValue = KeyValue> {
+    new (umd: FlowplayerUMD, player: Player): AnyPlugin<PluginOwnConfig>;
+}
+
+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 { }