kplayer-ts 1.0.0 → 1.0.2

package/dist/main.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/template/player.d.ts

@@ -0,0 +1,21 @@
+import { KPlayerOptions } from '../ts/types';
+import { default as Icons } from '../ts/icons';
+interface RenderPlayerOptions {
+    options: KPlayerOptions;
+    index: number;
+    tran: (key: string) => string;
+    icons: typeof Icons;
+    mobile: boolean;
+    video: {
+        current: boolean;
+        pic?: string;
+        screenshot?: boolean;
+        airplay?: boolean;
+        chromecast?: boolean;
+        preload?: string;
+        url?: string;
+        subtitle?: KPlayerOptions["subtitle"];
+    };
+}
+export default function renderPlayer({ options, index: _index, tran, icons, mobile: _mobile, video, }: RenderPlayerOptions): string;
+export {};

package/dist/template/video.d.ts

@@ -0,0 +1,12 @@
+import { SubtitleOptions } from '../ts/types';
+interface RenderVideoOptions {
+    current?: boolean;
+    airplay?: boolean;
+    pic?: string;
+    screenshot?: boolean;
+    preload?: string;
+    url?: string;
+    subtitle?: SubtitleOptions | null;
+}
+export default function renderVideo({ current, airplay, pic, screenshot, preload, url, subtitle, }?: RenderVideoOptions): string;
+export {};

package/dist/ts/ad.d.ts

@@ -0,0 +1,39 @@
+import { default as Kplayer } from './player';
+import { AdItem } from './types';
+declare class Ad {
+    player: Kplayer;
+    options: {
+        url: AdItem[];
+    } | null;
+    currentAd: AdItem | null;
+    adContainer: HTMLDivElement | null;
+    adContent: HTMLDivElement;
+    skipBtn: HTMLButtonElement;
+    deeplinkBtn: HTMLButtonElement;
+    adLabel: HTMLDivElement;
+    skipTimer?: ReturnType<typeof setInterval>;
+    skipRemaining: number;
+    adMarkers: HTMLElement[];
+    private _timeUpdateBound;
+    private _shownAds;
+    private _adVideo;
+    constructor(player: Kplayer);
+    private _createAdContainer;
+    private _createMarker;
+    private _renderBarMarkers;
+    private _bindTimeUpdate;
+    private _showAd;
+    private _showImageAd;
+    private _showTextAd;
+    private _showVideoAd;
+    private _startSkipTimer;
+    private _skipAd;
+    private _closeAd;
+    _loadVAST(url: string): Promise<void>;
+    private _fetchVASTAndRegister;
+    private _registerVMAPMarkers;
+    private _parseVASTAndShow;
+    private _parseTime;
+    destroy(): void;
+}
+export default Ad;

package/dist/ts/bar.d.ts

@@ -0,0 +1,10 @@
+import { default as Template } from './template';
+type BarType = "volume" | "played" | "loaded" | "awaken";
+type BarDirection = "width" | "height";
+declare class Bar {
+    elements: Partial<Record<BarType, HTMLElement>>;
+    constructor(template: Template);
+    set(type: BarType, percentage: number, direction: BarDirection): void;
+    get(type: BarType): number;
+}
+export default Bar;

package/dist/ts/bezel.d.ts

@@ -0,0 +1,6 @@
+declare class Bezel {
+    container: HTMLElement;
+    constructor(container: HTMLElement);
+    switch(icon: string): void;
+}
+export default Bezel;

package/dist/ts/contextmenu.d.ts

@@ -0,0 +1,12 @@
+import { default as KPlayer } from './player';
+declare class ContextMenu {
+    player: KPlayer;
+    shown: boolean;
+    contextmenuHandler: (e: MouseEvent) => void;
+    videoContextHandler: (e: MouseEvent) => void;
+    constructor(player: KPlayer);
+    show(x: number, y: number): void;
+    hide(): void;
+    destroy(): void;
+}
+export default ContextMenu;

package/dist/ts/controller.d.ts

@@ -0,0 +1,38 @@
+import { default as Thumbnails } from './thumbnails';
+import { default as KPlayer } from './player';
+declare class Controller {
+    player: KPlayer;
+    autoHideTimer: number;
+    disableAutoHide: boolean;
+    thumbnails?: Thumbnails;
+    setAutoHideHandler?: () => void;
+    private _skipBtn;
+    private _skipTarget;
+    private session;
+    private currentMedia;
+    constructor(player: KPlayer);
+    initPlayButton(): void;
+    initSeekButtons(): void;
+    initHighlights(): void;
+    private _createSkipButton;
+    private _updateSkipButton;
+    initThumbnails(): void;
+    initPlayedBar(): void;
+    initFullButton(): void;
+    initVolumeButton(): void;
+    initQualityButton(): void;
+    initScreenshotButton(): void;
+    initAirplayButton(): void;
+    initChromecast(): void;
+    initChromecastButton(): void;
+    initSubtitleButton(): void;
+    _showTitleBar(): void;
+    _hideTitleBar(): void;
+    setAutoHide(): void;
+    show(): void;
+    hide(): void;
+    isShow(): boolean;
+    toggle(): void;
+    destroy(): void;
+}
+export default Controller;

package/dist/ts/events.d.ts

@@ -0,0 +1,11 @@
+type EventCallback = (info?: unknown) => void;
+declare class Events {
+    events: Record<string, EventCallback[]>;
+    videoEvents: string[];
+    playerEvents: string[];
+    constructor();
+    on(name: string, callback: EventCallback): void;
+    trigger(name: string, info?: unknown): void;
+    type(name: string): string | null;
+}
+export default Events;

package/dist/ts/fullscreen.d.ts

@@ -0,0 +1,15 @@
+import { default as KPlayer } from './player';
+import { FullScreenType, ScrollPosition } from './types';
+declare class FullScreen {
+    player: KPlayer;
+    lastScrollPosition: ScrollPosition;
+    fullscreenchange: () => void;
+    docfullscreenchange: () => void;
+    constructor(player: KPlayer);
+    isFullScreen(type?: FullScreenType): Element | boolean | null;
+    request(type?: FullScreenType): void;
+    cancel(type?: FullScreenType): void;
+    toggle(type?: FullScreenType): void;
+    destroy(): void;
+}
+export default FullScreen;

package/dist/ts/hotkey.d.ts

@@ -0,0 +1,11 @@
+import { default as KPlayer } from './player';
+declare class HotKey {
+    player: KPlayer;
+    doHotKeyHandler: (e: KeyboardEvent) => void;
+    cancelFullScreenHandler: (e: KeyboardEvent) => void;
+    constructor(player: KPlayer);
+    doHotKey(e: KeyboardEvent): void;
+    cancelFullScreen(e: KeyboardEvent): void;
+    destroy(): void;
+}
+export default HotKey;

package/dist/ts/i18n.d.ts

@@ -0,0 +1,6 @@
+declare function i18n(this: {
+    lang: string;
+    fallbackLang: string;
+    tran: (key: string) => string;
+}, lang: string): void;
+export { i18n };

package/dist/ts/icons.d.ts

@@ -0,0 +1,22 @@
+declare const Icons: {
+    play: string;
+    pause: string;
+    volumeUp: string;
+    volumeDown: string;
+    volumeOff: string;
+    full: string;
+    fullWeb: string;
+    setting: string;
+    right: string;
+    pallette: string;
+    camera: string;
+    subtitle: string;
+    loading: string;
+    airplay: string;
+    chromecast: string;
+    back: string;
+    rewind: string;
+    forward: string;
+    video: string;
+};
+export default Icons;

package/dist/ts/index.d.ts

@@ -0,0 +1,3 @@
+import { default as KPlayer } from './player';
+export default KPlayer;
+export type { KPlayerOptions, VideoQuality, SubtitleOptions, SubtitleItem, AdOptions, AdItem, HighlightItem, TitleOptions, ContextMenuItem, } from './types';

package/dist/ts/info-panel.d.ts

@@ -0,0 +1,16 @@
+import { default as KPlayer } from './player';
+import { default as Template } from './template';
+declare class InfoPanel {
+    container: HTMLElement;
+    template: Template;
+    video: HTMLVideoElement;
+    player: KPlayer;
+    beginTime: number;
+    constructor(player: KPlayer);
+    show(): void;
+    hide(): void;
+    triggle(): void;
+    update(): void;
+    fps(value: number): void;
+}
+export default InfoPanel;

package/dist/ts/options.d.ts

@@ -0,0 +1,5 @@
+import { KPlayerOptions } from './types';
+declare const _default: (options: Partial<KPlayerOptions> & {
+    video: KPlayerOptions["video"];
+}) => KPlayerOptions;
+export default _default;

package/dist/ts/player.d.ts

@@ -0,0 +1,107 @@
+import { default as Template } from './template';
+import { default as Ad } from './ad';
+import { default as Events } from './events';
+import { default as FullScreen } from './fullscreen';
+import { default as User } from './user';
+import { default as Subtitle } from './subtitle';
+import { default as Subtitles } from './subtitles';
+import { default as Bar } from './bar';
+import { default as Timer } from './timer';
+import { default as Bezel } from './bezel';
+import { default as Controller } from './controller';
+import { default as Setting } from './setting';
+import { default as HotKey } from './hotkey';
+import { default as ContextMenu } from './contextmenu';
+import { default as InfoPanel } from './info-panel';
+import { KPlayerOptions } from './types';
+interface HlsLevel {
+    height?: number;
+    bitrate?: number;
+}
+interface HlsInstance {
+    levels: HlsLevel[];
+    currentLevel: number;
+    nextLevel: number;
+    loadLevel: number;
+    autoLevelEnabled: boolean;
+    loadSource(src: string): void;
+    attachMedia(video: HTMLVideoElement): void;
+    destroy(): void;
+    on(event: string, cb: (...args: unknown[]) => void): void;
+    off(event: string, cb: (...args: unknown[]) => void): void;
+    DefaultConfig?: {
+        loader: unknown;
+    };
+}
+declare class KPlayer {
+    options: KPlayerOptions;
+    tran: (key: string) => string;
+    events: Events;
+    user: User;
+    container: HTMLElement;
+    noticeList: Record<string, ReturnType<typeof setTimeout> | null>;
+    hlsQualityList: unknown[];
+    hlsCurrentLevel: number;
+    hlsAutoEnabled: boolean;
+    template: Template;
+    video: HTMLVideoElement;
+    bar: Bar;
+    bezel: Bezel;
+    fullScreen: FullScreen;
+    controller: Controller;
+    setting: Setting;
+    plugins: Record<string, unknown>;
+    docClickFun: () => void;
+    containerClickFun: () => void;
+    focus: boolean;
+    paused: boolean;
+    timer: Timer;
+    hotkey: HotKey;
+    contextmenu: ContextMenu;
+    infoPanel: InfoPanel;
+    ad?: Ad;
+    subtitle?: Subtitle;
+    subtitles?: Subtitles;
+    awaken?: unknown;
+    moveBar: boolean;
+    type?: string;
+    qualityIndex?: number;
+    quality?: {
+        name: string;
+        url: string;
+        type?: string;
+    };
+    switchingQuality: boolean;
+    prevIndex?: number;
+    prevVideo?: HTMLVideoElement;
+    constructor(options: Partial<KPlayerOptions> & {
+        video: KPlayerOptions["video"];
+    });
+    seek(time: number): void;
+    play(fromNative?: boolean): void;
+    pause(fromNative?: boolean): void;
+    switchVolumeIcon(): void;
+    volume(percentage?: number, nostorage?: boolean, nonotice?: boolean): number;
+    toggle(): void;
+    on(name: string, callback: (info?: unknown) => void): void;
+    initMSE(video: HTMLVideoElement, type: string): void;
+    initVideo(video: HTMLVideoElement, type: string): void;
+    getHlsLevelLabel(level: HlsLevel): string;
+    updateHlsQualityCurrentLabel(): void;
+    buildHlsQualityMenu(hls: HlsInstance, HlsLib: {
+        Events: Record<string, string>;
+        isSupported: () => boolean;
+        DefaultConfig: {
+            loader: unknown;
+        };
+    } & (new (opts: unknown) => HlsInstance)): void;
+    switchQuality(index: number | string): void;
+    notice(text: string, time?: number, opacity?: number, id?: string): void;
+    resize(): void;
+    speed(rate: number): void;
+    destroy(): void;
+    static get version(): string;
+    private _loadSubtitleTexts;
+    loadSubtitleByIndex(index: number): Promise<void>;
+}
+export default KPlayer;

package/dist/ts/setting.d.ts

@@ -0,0 +1,14 @@
+import { default as KPlayer } from './player';
+declare class Setting {
+    player: KPlayer;
+    loop: boolean;
+    showAwaken: number;
+    unlimitAwaken: number;
+    airplayEntry: HTMLElement | null;
+    chromecastEntry: HTMLElement | null;
+    screenshotEntry: HTMLElement | null;
+    constructor(player: KPlayer);
+    hide(): void;
+    show(): void;
+}
+export default Setting;

package/dist/ts/subtitle.d.ts

@@ -0,0 +1,22 @@
+import { default as Events } from './events';
+import { SubtitleOptions } from './types';
+declare class Subtitle {
+    container: HTMLElement;
+    video: HTMLVideoElement;
+    options: SubtitleOptions;
+    events: Events;
+    private _track;
+    constructor(container: HTMLElement, video: HTMLVideoElement, options: SubtitleOptions, events: Events);
+    init(): void;
+    loadVttText(vttText: string): Promise<void>;
+    private _onTimeUpdateBound?;
+    private _onTimeUpdate;
+    private _clearTrack;
+    private _parseVtt;
+    private _timeToSeconds;
+    show(): void;
+    hide(): void;
+    toggle(): void;
+    destroy(): void;
+}
+export default Subtitle;

package/dist/ts/subtitles.d.ts

@@ -0,0 +1,19 @@
+import { default as KPlayer } from './player';
+declare class Subtitles {
+    player: KPlayer;
+    constructor(player: KPlayer);
+    reloadTrack(): void;
+    clearSelected(): void;
+    selectSubtitle(index: number): void;
+    selectOff(): void;
+    subContainerShow(): void;
+    subContainerHide(): void;
+    hide(): void;
+    show(): void;
+    adaptiveHeight(): void;
+    updateUrls(urls: Array<{
+        url?: string;
+        lang?: string;
+    }>): void;
+}
+export default Subtitles;

package/dist/ts/template.d.ts

@@ -0,0 +1,94 @@
+import { KPlayerOptions } from './types';
+interface TemplateOptions {
+    container: HTMLElement;
+    options: KPlayerOptions;
+    index: number;
+    tran: (key: string) => string;
+}
+declare class Template {
+    container: HTMLElement;
+    options: KPlayerOptions;
+    index: number;
+    tran: (key: string) => string;
+    volumeBar: HTMLElement;
+    volumeBarWrap: HTMLElement;
+    volumeBarWrapWrap: HTMLElement;
+    volumeButton: HTMLElement;
+    volumeButtonIcon: HTMLElement;
+    volumeIcon: HTMLElement;
+    playedBar: HTMLElement;
+    loadedBar: HTMLElement;
+    playedBarWrap: HTMLElement;
+    playedBarTime: HTMLElement;
+    awaken: HTMLElement | null;
+    awakenLoading: HTMLElement | null;
+    video: HTMLVideoElement;
+    bezel: HTMLElement;
+    playButton: HTMLElement;
+    mobilePlayButton: HTMLElement;
+    videoWrap: HTMLElement;
+    controllerMask: HTMLElement;
+    ptime: HTMLElement;
+    settingButton: HTMLElement;
+    settingBox: HTMLElement;
+    mask: HTMLElement;
+    loop: HTMLElement;
+    loopToggle: HTMLInputElement;
+    showAwaken: HTMLElement;
+    showAwakenToggle: HTMLInputElement;
+    unlimitAwaken: HTMLElement;
+    unlimitAwakenToggle: HTMLInputElement;
+    speed: HTMLElement;
+    speedItem: NodeListOf<HTMLElement>;
+    awakenOpacityBar: HTMLElement | null;
+    awakenOpacityBarWrap: HTMLElement | null;
+    awakenOpacityBarWrapWrap: HTMLElement | null;
+    awakenOpacityBox: HTMLElement | null;
+    dtime: HTMLElement;
+    controller: HTMLElement;
+    browserFullButton: HTMLElement;
+    webFullButton: HTMLElement;
+    menu: HTMLElement;
+    menuItem: NodeListOf<HTMLElement>;
+    qualityList: HTMLElement;
+    camareButton: HTMLElement | null;
+    airplayButton: HTMLElement | null;
+    chromecastButton: HTMLElement | null;
+    subtitleButton: HTMLElement | null;
+    subtitleButtonInner: HTMLElement | null;
+    subtitlesBox: HTMLElement | null;
+    subtitlesItem: NodeListOf<HTMLElement>;
+    subtitle: HTMLElement;
+    subtrack: HTMLTrackElement | null;
+    barPreview: HTMLElement;
+    barWrap: HTMLElement;
+    noticeList: HTMLElement;
+    infoPanel: HTMLElement | null;
+    infoPanelClose: HTMLElement | null;
+    infoVersion: HTMLElement | null;
+    infoFPS: HTMLElement | null;
+    infoType: HTMLElement | null;
+    infoUrl: HTMLElement | null;
+    infoResolution: HTMLElement | null;
+    infoDuration: HTMLElement | null;
+    infoAwakenId: HTMLElement | null;
+    infoAwakenApi: HTMLElement | null;
+    infoAwakenAmount: HTMLElement | null;
+    subtitlesButton: HTMLElement | {
+        addEventListener: () => void;
+        dataset: Record<string, string>;
+        style: Record<string, string>;
+    };
+    qualityButton: HTMLElement;
+    titleBar: HTMLElement | null;
+    titleBack: HTMLElement | null;
+    titleMain: HTMLElement | null;
+    titleDesc: HTMLElement | null;
+    subtitleEntry: HTMLElement | null;
+    qualityEntry: HTMLElement | null;
+    qualityItems: NodeListOf<HTMLElement>;
+    constructor(options: TemplateOptions);
+    init(): void;
+    static NewNotice(text: string, opacity: number, id?: string): HTMLElement;
+}
+export default Template;

package/dist/ts/thumbnails.d.ts

@@ -0,0 +1,18 @@
+import { default as Events } from './events';
+interface ThumbnailsOptions {
+    container: HTMLElement;
+    barWidth: number;
+    url: string;
+    events?: Events;
+}
+declare class Thumbnails {
+    container: HTMLElement;
+    barWidth: number;
+    events?: Events;
+    constructor(options: ThumbnailsOptions);
+    resize(width: number, height: number, barWrapWidth: number): void;
+    show(): void;
+    move(position: number): void;
+    hide(): void;
+}
+export default Thumbnails;

package/dist/ts/timer.d.ts

@@ -0,0 +1,22 @@
+import { default as KPlayer } from './player';
+type TimerType = "loading" | "info" | "fps";
+declare class Timer {
+    player: KPlayer;
+    types: TimerType[];
+    loadingChecker?: ReturnType<typeof setInterval>;
+    infoChecker?: ReturnType<typeof setInterval>;
+    enableloadingChecker: boolean;
+    enableinfoChecker: boolean;
+    enablefpsChecker: boolean;
+    fpsStart?: Date;
+    fpsIndex: number;
+    constructor(player: KPlayer);
+    init(): void;
+    initloadingChecker(): void;
+    initfpsChecker(): void;
+    initinfoChecker(): void;
+    enable(type: TimerType): void;
+    disable(type: TimerType): void;
+    destroy(): void;
+}
+export default Timer;