@hanifhan1f/vidstack 1.12.13

package/types/core/state/remote-control.d.ts

@@ -0,0 +1,288 @@
+import type { ScreenOrientationLockType } from '../..';
+import type { MediaPlayer } from '../../components/player';
+import { Logger } from '../../foundation/logger/controller';
+import type { MediaFullscreenRequestTarget } from '../api/media-request-events';
+/**
+ * A simple facade for dispatching media requests to the nearest media player element.
+ *
+ * @docs {@link https://www.vidstack.io/docs/player/core-concepts/state-management#updating}
+ *
+ */
+export declare class MediaRemoteControl {
+    #private;
+    constructor(logger?: Logger | undefined);
+    /**
+     * Set the target from which to dispatch media requests events from. The events should bubble
+     * up from this target to the player element.
+     *
+     * @example
+     * ```ts
+     * const button = document.querySelector('button');
+     * remote.setTarget(button);
+     * ```
+     */
+    setTarget(target: EventTarget | null): void;
+    /**
+     * Returns the current player element. This method will attempt to find the player by
+     * searching up from either the given `target` or default target set via `remote.setTarget`.
+     *
+     * @example
+     * ```ts
+     * const player = remote.getPlayer();
+     * ```
+     */
+    getPlayer(target?: EventTarget | null): MediaPlayer | null;
+    /**
+     * Set the current player element so the remote can support toggle methods such as
+     * `togglePaused` as they rely on the current media state.
+     */
+    setPlayer(player: MediaPlayer | null): void;
+    /**
+     * Dispatch a request to start the media loading process. This will only work if the media
+     * player has been initialized with a custom loading strategy `load="custom">`.
+     *
+     * @docs {@link https://www.vidstack.io/docs/player/core-concepts/loading#load-strategies}
+     */
+    startLoading(trigger?: Event): void;
+    /**
+     * Dispatch a request to start the poster loading process. This will only work if the media
+     * player has been initialized with a custom poster loading strategy `posterLoad="custom">`.
+     *
+     * @docs {@link https://www.vidstack.io/docs/player/core-concepts/loading#load-strategies}
+     */
+    startLoadingPoster(trigger?: Event): void;
+    /**
+     * Dispatch a request to connect to AirPlay.
+     *
+     * @see {@link https://www.apple.com/au/airplay}
+     */
+    requestAirPlay(trigger?: Event): void;
+    /**
+     * Dispatch a request to connect to Google Cast.
+     *
+     * @see {@link https://developers.google.com/cast/docs/overview}
+     */
+    requestGoogleCast(trigger?: Event): void;
+    /**
+     * Dispatch a request to begin/resume media playback.
+     */
+    play(trigger?: Event): void;
+    /**
+     * Dispatch a request to pause media playback.
+     */
+    pause(trigger?: Event): void;
+    /**
+     * Dispatch a request to set the media volume to mute (0).
+     */
+    mute(trigger?: Event): void;
+    /**
+     * Dispatch a request to unmute the media volume and set it back to it's previous state.
+     */
+    unmute(trigger?: Event): void;
+    /**
+     * Dispatch a request to enter fullscreen.
+     *
+     * @docs {@link https://www.vidstack.io/docs/player/api/fullscreen#remote-control}
+     */
+    enterFullscreen(target?: MediaFullscreenRequestTarget, trigger?: Event): void;
+    /**
+     * Dispatch a request to exit fullscreen.
+     *
+     * @docs {@link https://www.vidstack.io/docs/player/api/fullscreen#remote-control}
+     */
+    exitFullscreen(target?: MediaFullscreenRequestTarget, trigger?: Event): void;
+    /**
+     * Dispatch a request to lock the screen orientation.
+     *
+     * @docs {@link https://www.vidstack.io/docs/player/screen-orientation#remote-control}
+     */
+    lockScreenOrientation(lockType: ScreenOrientationLockType, trigger?: Event): void;
+    /**
+     * Dispatch a request to unlock the screen orientation.
+     *
+     * @docs {@link https://www.vidstack.io/docs/player/api/screen-orientation#remote-control}
+     */
+    unlockScreenOrientation(trigger?: Event): void;
+    /**
+     * Dispatch a request to enter picture-in-picture mode.
+     *
+     * @docs {@link https://www.vidstack.io/docs/player/api/picture-in-picture#remote-control}
+     */
+    enterPictureInPicture(trigger?: Event): void;
+    /**
+     * Dispatch a request to exit picture-in-picture mode.
+     *
+     * @docs {@link https://www.vidstack.io/docs/player/api/picture-in-picture#remote-control}
+     */
+    exitPictureInPicture(trigger?: Event): void;
+    /**
+     * Notify the media player that a seeking process is happening and to seek to the given `time`.
+     */
+    seeking(time: number, trigger?: Event): void;
+    /**
+     * Notify the media player that a seeking operation has completed and to seek to the given `time`.
+     * This is generally called after a series of `remote.seeking()` calls.
+     */
+    seek(time: number, trigger?: Event): void;
+    seekToLiveEdge(trigger?: Event): void;
+    /**
+     * Dispatch a request to update the length of the media in seconds.
+     *
+     * @example
+     * ```ts
+     * remote.changeDuration(100); // 100 seconds
+     * ```
+     */
+    changeDuration(duration: number, trigger?: Event): void;
+    /**
+     * Dispatch a request to update the clip start time. This is the time at which media playback
+     * should start at.
+     *
+     * @example
+     * ```ts
+     * remote.changeClipStart(100); // start at 100 seconds
+     * ```
+     */
+    changeClipStart(startTime: number, trigger?: Event): void;
+    /**
+     * Dispatch a request to update the clip end time. This is the time at which media playback
+     * should end at.
+     *
+     * @example
+     * ```ts
+     * remote.changeClipEnd(100); // end at 100 seconds
+     * ```
+     */
+    changeClipEnd(endTime: number, trigger?: Event): void;
+    /**
+     * Dispatch a request to update the media volume to the given `volume` level which is a value
+     * between 0 and 1.
+     *
+     * @docs {@link https://www.vidstack.io/docs/player/api/audio-gain#remote-control}
+     * @example
+     * ```ts
+     * remote.changeVolume(0); // 0%
+     * remote.changeVolume(0.05); // 5%
+     * remote.changeVolume(0.5); // 50%
+     * remote.changeVolume(0.75); // 70%
+     * remote.changeVolume(1); // 100%
+     * ```
+     */
+    changeVolume(volume: number, trigger?: Event): void;
+    /**
+     * Dispatch a request to change the current audio track.
+     *
+     * @example
+     * ```ts
+     * remote.changeAudioTrack(1); // track at index 1
+     * ```
+     */
+    changeAudioTrack(index: number, trigger?: Event): void;
+    /**
+     * Dispatch a request to change the video quality. The special value `-1` represents auto quality
+     * selection.
+     *
+     * @example
+     * ```ts
+     * remote.changeQuality(-1); // auto
+     * remote.changeQuality(1); // quality at index 1
+     * ```
+     */
+    changeQuality(index: number, trigger?: Event): void;
+    /**
+     * Request auto quality selection.
+     */
+    requestAutoQuality(trigger?: Event): void;
+    /**
+     * Dispatch a request to change the mode of the text track at the given index.
+     *
+     * @example
+     * ```ts
+     * remote.changeTextTrackMode(1, 'showing'); // track at index 1
+     * ```
+     */
+    changeTextTrackMode(index: number, mode: TextTrackMode, trigger?: Event): void;
+    /**
+     * Dispatch a request to change the media playback rate.
+     *
+     * @example
+     * ```ts
+     * remote.changePlaybackRate(0.5); // Half the normal speed
+     * remote.changePlaybackRate(1); // Normal speed
+     * remote.changePlaybackRate(1.5); // 50% faster than normal
+     * remote.changePlaybackRate(2); // Double the normal speed
+     * ```
+     */
+    changePlaybackRate(rate: number, trigger?: Event): void;
+    /**
+     * Dispatch a request to change the media audio gain.
+     *
+     * @example
+     * ```ts
+     * remote.changeAudioGain(1); // Disable audio gain
+     * remote.changeAudioGain(1.5); // 50% louder
+     * remote.changeAudioGain(2); // 100% louder
+     * ```
+     */
+    changeAudioGain(gain: number, trigger?: Event): void;
+    /**
+     * Dispatch a request to resume idle tracking on controls.
+     */
+    resumeControls(trigger?: Event): void;
+    /**
+     * Dispatch a request to pause controls idle tracking. Pausing tracking will result in the
+     * controls being visible until `remote.resumeControls()` is called. This method
+     * is generally used when building custom controls and you'd like to prevent the UI from
+     * disappearing.
+     *
+     * @example
+     * ```ts
+     * // Prevent controls hiding while menu is being interacted with.
+     * function onSettingsOpen() {
+     *   remote.pauseControls();
+     * }
+     *
+     * function onSettingsClose() {
+     *   remote.resumeControls();
+     * }
+     * ```
+     */
+    pauseControls(trigger?: Event): void;
+    /**
+     * Dispatch a request to toggle the media playback state.
+     */
+    togglePaused(trigger?: Event): void;
+    /**
+     * Dispatch a request to toggle the controls visibility.
+     */
+    toggleControls(trigger?: Event): void;
+    /**
+     * Dispatch a request to toggle the media muted state.
+     */
+    toggleMuted(trigger?: Event): void;
+    /**
+     * Dispatch a request to toggle the media fullscreen state.
+     *
+     * @docs {@link https://www.vidstack.io/docs/player/api/fullscreen#remote-control}
+     */
+    toggleFullscreen(target?: MediaFullscreenRequestTarget, trigger?: Event): void;
+    /**
+     * Dispatch a request to toggle the media picture-in-picture mode.
+     *
+     * @docs {@link https://www.vidstack.io/docs/player/api/picture-in-picture#remote-control}
+     */
+    togglePictureInPicture(trigger?: Event): void;
+    /**
+     * Show captions.
+     */
+    showCaptions(trigger?: Event): void;
+    /**
+     * Turn captions off.
+     */
+    disableCaptions(trigger?: Event): void;
+    /**
+     * Dispatch a request to toggle the current captions mode.
+     */
+    toggleCaptions(trigger?: Event): void;
+    userPrefersLoopChange(prefersLoop: boolean, trigger?: Event): void;
+}

package/types/core/state/tracked-media-events.d.ts

@@ -0,0 +1,2 @@
+import type { MediaEvents } from '../api/media-events';
+export declare const TRACKED_EVENT: Set<keyof MediaEvents>;

package/types/core/time-ranges.d.ts

@@ -0,0 +1,12 @@
+export type TimeInterval = [start: number, end: number];
+export declare class TimeRange implements TimeRanges {
+    #private;
+    get length(): number;
+    constructor(start?: number | TimeInterval[], end?: number);
+    start(index: number): number;
+    end(index: number): number;
+}
+export declare function getTimeRangesStart(range: TimeRanges): number | null;
+export declare function getTimeRangesEnd(range: TimeRanges): number | null;
+export declare function normalizeTimeIntervals(intervals: TimeInterval[]): TimeInterval[];
+export declare function updateTimeIntervals(intervals: TimeInterval[], interval: TimeInterval, value: number): TimeInterval;

package/types/core/tracks/audio/audio-tracks.d.ts

@@ -0,0 +1,32 @@
+import { SelectList, type SelectListItem } from '../../../foundation/list/select-list';
+import type { AudioTrackListEvents } from './events';
+/**
+ * @see {@link https://vidstack.io/docs/player/api/audio-tracks}
+ */
+export declare class AudioTrackList extends SelectList<AudioTrack, AudioTrackListEvents> {
+}
+/**
+ * @see {@link https://vidstack.io/docs/player/api/audio-tracks}
+ */
+export interface AudioTrack extends SelectListItem {
+    /**
+     * A string which uniquely identifies the track within the media.
+     */
+    readonly id: string;
+    /**
+     * A human-readable label for the track, or an empty string if unknown.
+     */
+    readonly label: string;
+    /**
+     * A string specifying the audio track's primary language, or an empty string if unknown. The
+     * language is specified as a BCP 47 (RFC 5646) language code, such as "en-US" or "pt-BR".
+     */
+    readonly language: string;
+    /**
+     * A string specifying the category into which the track falls. For example, the main audio
+     * track would have a kind of "main".
+     *
+     * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/AudioTrack/kind}
+     */
+    readonly kind: string;
+}

package/types/core/tracks/audio/events.d.ts

@@ -0,0 +1,37 @@
+import type { DOMEvent } from 'maverick.js/std';
+import type { ListReadonlyChangeEvent } from '../../../foundation/list/list';
+import type { AudioTrack, AudioTrackList } from './audio-tracks';
+export interface AudioTrackListEvents {
+    add: AudioTrackAddEvent;
+    remove: AudioTrackRemoveEvent;
+    change: AudioTrackChangeEvent;
+    'readonly-change': ListReadonlyChangeEvent;
+}
+export interface AudioTrackListEvent<T> extends DOMEvent<T> {
+    target: AudioTrackList;
+}
+/**
+ * Fired when an audio track has been added to the list.
+ *
+ * @detail newTrack
+ */
+export interface AudioTrackAddEvent extends AudioTrackListEvent<AudioTrack> {
+}
+/**
+ * Fired when an audio track has been removed from the list.
+ *
+ * @detail removedTrack
+ */
+export interface AudioTrackRemoveEvent extends AudioTrackListEvent<AudioTrack> {
+}
+/**
+ * Fired when the selected audio track has changed.
+ *
+ * @detail change
+ */
+export interface AudioTrackChangeEvent extends AudioTrackListEvent<ChangeAudioTrackEventDetail> {
+}
+export interface ChangeAudioTrackEventDetail {
+    prev: AudioTrack | null;
+    current: AudioTrack;
+}

package/types/core/tracks/text/events.d.ts

@@ -0,0 +1,49 @@
+import type { DOMEvent } from 'maverick.js/std';
+import type { TextTrack } from './text-track';
+export interface TextTrackEvents {
+    'load-start': TextTrackLoadStartEvent;
+    load: TextTrackLoadEvent;
+    error: TextTrackErrorEvent;
+    'add-cue': TextTrackAddCueEvent;
+    'remove-cue': TextTrackRemoveCueEvent;
+    'cue-change': TextTrackCueChangeEvent;
+    'mode-change': TextTrackModeChangeEvent;
+}
+export interface TextTrackEvent<T> extends DOMEvent<T> {
+    target: TextTrack;
+}
+/**
+ * Fired when the text track begins the loading/parsing process.
+ */
+export interface TextTrackLoadStartEvent extends TextTrackEvent<void> {
+}
+/**
+ * Fired when the text track has finished loading/parsing.
+ */
+export interface TextTrackLoadEvent extends TextTrackEvent<void> {
+}
+/**
+ * Fired when loading or parsing the text track fails.
+ */
+export interface TextTrackErrorEvent extends TextTrackEvent<Error> {
+}
+/**
+ * Fired when a cue is added to the text track.
+ */
+export interface TextTrackAddCueEvent extends TextTrackEvent<VTTCue> {
+}
+/**
+ * Fired when a cue is removed from the text track.
+ */
+export interface TextTrackRemoveCueEvent extends TextTrackEvent<VTTCue> {
+}
+/**
+ * Fired when the active cues for the current text track have changed.
+ */
+export interface TextTrackCueChangeEvent extends TextTrackEvent<void> {
+}
+/**
+ * Fired when the text track mode (showing/hidden/disabled) has changed.
+ */
+export interface TextTrackModeChangeEvent extends TextTrackEvent<TextTrack> {
+}

package/types/core/tracks/text/render/libass-text-renderer.d.ts

@@ -0,0 +1,181 @@
+import { EventsTarget } from 'maverick.js/std';
+import type { TextTrack } from '../text-track';
+import type { TextRenderer } from './text-renderer';
+export declare class LibASSTextRenderer implements TextRenderer {
+    #private;
+    readonly loader: LibASSModuleLoader;
+    config?: LibASSConfig | undefined;
+    readonly priority = 1;
+    constructor(loader: LibASSModuleLoader, config?: LibASSConfig | undefined);
+    canRender(track: TextTrack, video: HTMLVideoElement | null): boolean;
+    attach(video: HTMLVideoElement | null): void;
+    changeTrack(track: TextTrack | null): void;
+    detach(): void;
+}
+export interface LibASSModuleLoader {
+    (): Promise<{
+        default: LibASSConstructor;
+    }>;
+}
+export interface LibASSConstructor {
+    new (config?: {
+        video: HTMLVideoElement;
+        canvas?: HTMLCanvasElement;
+        subUrl?: string;
+    } & LibASSConfig): LibASSInstance;
+}
+export interface LibASSInstance extends EventsTarget<LibASSInstanceEvents> {
+    _video: HTMLVideoElement;
+    _canvas: HTMLVideoElement | null;
+    setTrackByUrl(url: string): void;
+    setCurrentTime(time: number): void;
+    freeTrack(): void;
+    destroy(): void;
+}
+export interface LibASSInstanceEvents {
+    ready: LibASSReadyEvent;
+    error: LibASSErrorEvent;
+}
+export interface LibASSReadyEvent extends Event {
+}
+export interface LibASSErrorEvent extends ErrorEvent {
+}
+/**
+ * @see {@link https://github.com/ThaUnknown/jassub/tree/main#options}
+ */
+export interface LibASSConfig {
+    /**
+     * Which image blending mode to use. WASM will perform better on lower end devices, JS will
+     * perform better if the device and browser supports hardware acceleration.
+     *
+     * @defaultValue "js"
+     */
+    blendMode?: 'js' | 'wasm';
+    /**
+     * Whether or not to use async rendering, which offloads the CPU by creating image bitmaps on
+     * the GPU.
+     *
+     * @defaultValue true
+     */
+    asyncRender?: boolean;
+    /**
+     * Whether or not to render things fully on the worker, greatly reduces CPU usage.
+     *
+     * @defaultValue true
+     */
+    offscreenRender?: boolean;
+    /**
+     * Whether or not to render subtitles as the video player renders frames, rather than predicting
+     * which frame the player is on using events.
+     *
+     * @defaultValue true
+     */
+    onDemandRender?: boolean;
+    /**
+     * Target FPS to render subtitles at. Ignored when onDemandRender is enabled.
+     *
+     * @defaultValue 24
+     */
+    targetFps?: number;
+    /**
+     * Subtitle time offset in seconds.
+     *
+     * @defaultValue 0
+     */
+    timeOffset?: number;
+    /**
+     * Whether or not to print debug information.
+     *
+     * @defaultValue false
+     */
+    debug?: boolean;
+    /**
+     * Scale down (< 1.0) the subtitles canvas to improve performance at the expense of quality, or
+     * scale it up (> 1.0).
+     *
+     * @defaultValue 1.0
+     */
+    prescaleFactor?: number;
+    /**
+     * The height in pixels beyond which the subtitles canvas won't be pre-scaled.
+     *
+     * @defaultValue 1080
+     */
+    prescaleHeightLimit?: number;
+    /**
+     * The maximum rendering height in pixels of the subtitles canvas. Beyond this subtitles will
+     * be up-scaled by the browser.
+     *
+     * @defaultValue 0
+     */
+    maxRenderHeight?: number;
+    /**
+     * Attempt to discard all animated tags. Enabling this may severely mangle complex subtitles
+     * and should only be considered as an last ditch effort of uncertain success for hardware
+     * otherwise incapable of displaying anything. Will not reliably work with manually edited or
+     * allocated events.
+     *
+     * @defaultValue false
+     */
+    dropAllAnimations?: boolean;
+    /**
+     * The URL of the worker.
+     *
+     * @defaultValue "jassub-worker.js"
+     */
+    workerUrl?: string;
+    /**
+     * The URL of the legacy worker. Only loaded if the browser doesn't support WASM.
+     *
+     * @defaultValue "jassub-worker-legacy.js"
+     */
+    legacyWorkerUrl?: string;
+    /**
+     * The URL of the subtitle file to play.
+     *
+     */
+    subUrl?: string;
+    /**
+     * The content of the subtitle file to play.
+     *
+     */
+    subContent?: string;
+    /**
+     * An array of links or `Uint8Array` to the fonts used in the subtitle. If `Uint8Array` is used
+     * the array is copied, not referenced. This forces all the fonts in this array to be loaded
+     * by the renderer, regardless of if they are used.
+     *
+     */
+    fonts?: string[] | Uint8Array[];
+    /**
+     * Object with all available fonts. Key is font family in lower case, value is link or
+     * `Uint8Array`. These fonts are selectively loaded if detected as used in the current
+     * subtitle track.
+     *
+     * @defaultValue {'liberation sans': './default.woff2'}}
+     */
+    availableFonts?: Record<string, string>;
+    /**
+     * The font family key of the fallback font in `availableFonts` to use if the other font
+     * for the style is missing special glyphs or unicode.
+     *
+     * @defaultValue "liberation sans"
+     */
+    fallbackFont?: string;
+    /**
+     * If the Local Font Access API is enabled `[chrome://flags/#font-access]`, the library will
+     * query for permissions to use local fonts and use them if any are missing. The permission can
+     * be queried beforehand using `navigator.permissions.request({ name: 'local-fonts' })`.
+     *
+     * @defaultValue true
+     */
+    useLocalFonts?: boolean;
+    /**
+     * libass bitmap cache memory limit in MiB (approximate).
+     */
+    libassMemoryLimit?: number;
+    /**
+     * libass glyph cache memory limit in MiB (approximate).
+     */
+    libassGlyphLimit?: number;
+}

package/types/core/tracks/text/render/native-text-renderer.d.ts

@@ -0,0 +1,13 @@
+import type { TextTrack as VdsTextTrack } from '../text-track';
+import type { TextRenderer } from './text-renderer';
+export declare class NativeTextRenderer implements TextRenderer {
+    #private;
+    readonly priority = 0;
+    canRender(_: any, video: HTMLVideoElement | null): video is HTMLVideoElement;
+    attach(video: HTMLVideoElement | null): void;
+    addTrack(track: VdsTextTrack): void;
+    removeTrack(track: VdsTextTrack): void;
+    changeTrack(track: VdsTextTrack | null): void;
+    setDisplay(display: boolean): void;
+    detach(): void;
+}

package/types/core/tracks/text/render/text-renderer.d.ts

@@ -0,0 +1,17 @@
+import type { MediaContext } from '../../../api/media-context';
+import { TextTrack } from '../text-track';
+export declare class TextRenderers {
+    #private;
+    constructor(media: MediaContext);
+    add(renderer: TextRenderer): void;
+    remove(renderer: TextRenderer): void;
+    /** @internal */
+    attachVideo(video: HTMLVideoElement | null): void;
+}
+export interface TextRenderer {
+    readonly priority: number;
+    canRender(track: TextTrack, video: HTMLVideoElement | null): boolean;
+    attach(video: HTMLVideoElement | null): any;
+    detach(): void;
+    changeTrack(track: TextTrack | null): void;
+}

package/types/core/tracks/text/symbols.d.ts

@@ -0,0 +1,11 @@
+declare const CROSS_ORIGIN: unique symbol, READY_STATE: unique symbol, UPDATE_ACTIVE_CUES: unique symbol, CAN_LOAD: unique symbol, ON_MODE_CHANGE: unique symbol, NATIVE: unique symbol, NATIVE_HLS: unique symbol;
+export declare const TextTrackSymbol: {
+    readonly crossOrigin: typeof CROSS_ORIGIN;
+    readonly readyState: typeof READY_STATE;
+    readonly updateActiveCues: typeof UPDATE_ACTIVE_CUES;
+    readonly canLoad: typeof CAN_LOAD;
+    readonly onModeChange: typeof ON_MODE_CHANGE;
+    readonly native: typeof NATIVE;
+    readonly nativeHLS: typeof NATIVE_HLS;
+};
+export {};