@hanifhan1f/vidstack 1.12.13

package/types/foundation/list/list.d.ts

@@ -0,0 +1,64 @@
+import { DOMEvent, EventsTarget } from 'maverick.js/std';
+import { ListSymbol } from './symbols';
+export interface ListItem {
+    id: string;
+}
+export declare class List<Item extends ListItem, Events extends ListEvents> extends EventsTarget<Events> implements Iterable<Item> {
+    [index: number]: Item | undefined;
+    protected items: Item[];
+    /** @internal */
+    protected [ListSymbol.readonly]: boolean;
+    /** @internal */
+    protected [ListSymbol.onReset]?(trigger?: Event): void;
+    /** @internal */
+    protected [ListSymbol.onRemove]?(item: Item, trigger?: Event): void;
+    get length(): number;
+    get readonly(): boolean;
+    /**
+     * Returns the index of the first occurrence of the given item, or -1 if it is not present.
+     */
+    indexOf(item: Item): number;
+    /**
+     * Returns an item matching the given `id`, or `null` if not present.
+     */
+    getById(id: string): Item | null;
+    /**
+     * Transform list to an array.
+     */
+    toArray(): Item[];
+    [Symbol.iterator](): ArrayIterator<Item>;
+    /** @internal */
+    [ListSymbol.add](item: Item, trigger?: Event): void;
+    /** @internal */
+    [ListSymbol.remove](item: Item, trigger?: Event): void;
+    /** @internal */
+    [ListSymbol.reset](trigger?: Event): void;
+    /** @internal */
+    [ListSymbol.setReadonly](readonly: boolean, trigger?: Event): void;
+}
+export interface ListEvents<Item extends ListItem = ListItem> {
+    add: ListAddEvent<Item>;
+    remove: ListRemoveEvent<Item>;
+    'readonly-change': ListReadonlyChangeEvent;
+}
+/**
+ * Fired when an item has been added to the list.
+ *
+ * @detail item
+ */
+export interface ListAddEvent<Item extends ListItem> extends DOMEvent<Item> {
+}
+/**
+ * Fired when an item has been removed from the list.
+ *
+ * @detail item
+ */
+export interface ListRemoveEvent<Item extends ListItem> extends DOMEvent<Item> {
+}
+/**
+ * Fired when the readonly state of the list has changed.
+ *
+ * @detail isReadonly
+ */
+export interface ListReadonlyChangeEvent extends DOMEvent<boolean> {
+}

package/types/foundation/list/select-list.d.ts

@@ -0,0 +1,30 @@
+import { DOMEvent } from 'maverick.js/std';
+import { List, type ListEvents, type ListItem } from './list';
+import { ListSymbol } from './symbols';
+export interface SelectListItem extends ListItem {
+    selected: boolean;
+}
+export declare class SelectList<Item extends SelectListItem, Events extends SelectListEvents<Item>> extends List<Item, Events> {
+    get selected(): Item | null;
+    get selectedIndex(): number;
+    /** @internal */
+    protected [ListSymbol.onRemove](item: Item, trigger?: Event): void;
+    /** @internal */
+    protected [ListSymbol.onUserSelect]?(): void;
+    /** @internal */
+    [ListSymbol.add](item: Omit<Item, 'selected'>, trigger?: Event): void;
+    /** @internal */
+    [ListSymbol.select](item: Item | undefined, selected: boolean, trigger?: Event): void;
+}
+export interface SelectListEvents<Item extends SelectListItem = SelectListItem> extends ListEvents<Item> {
+    change: SelectListChangeEvent<Item>;
+}
+/**
+ * @detail change
+ */
+export interface SelectListChangeEvent<Item extends SelectListItem> extends DOMEvent<SelectListChangeEventDetail<Item>> {
+}
+export interface SelectListChangeEventDetail<Item extends SelectListItem> {
+    prev: Item | null;
+    current: Item | null;
+}

package/types/foundation/list/symbols.d.ts

@@ -0,0 +1,14 @@
+declare const ADD: unique symbol, REMOVE: unique symbol, RESET: unique symbol, SELECT: unique symbol, READONLY: unique symbol, SET_READONLY: unique symbol, ON_RESET: unique symbol, ON_REMOVE: unique symbol, ON_USER_SELECT: unique symbol;
+/** @internal */
+export declare const ListSymbol: {
+    readonly add: typeof ADD;
+    readonly remove: typeof REMOVE;
+    readonly reset: typeof RESET;
+    readonly select: typeof SELECT;
+    readonly readonly: typeof READONLY;
+    readonly setReadonly: typeof SET_READONLY;
+    readonly onReset: typeof ON_RESET;
+    readonly onRemove: typeof ON_REMOVE;
+    readonly onUserSelect: typeof ON_USER_SELECT;
+};
+export {};

package/types/foundation/logger/colors.d.ts

@@ -0,0 +1,5 @@
+export declare function getLogColor(key: string): string | undefined;
+export declare function saveLogColor(key: string, { color, overwrite }?: {
+    color?: string | undefined;
+    overwrite?: boolean | undefined;
+}): void;

package/types/foundation/logger/controller.d.ts

@@ -0,0 +1,20 @@
+import { ViewController } from 'maverick.js';
+import { GroupedLog } from './grouped-log';
+import type { LogLevel } from './log-level';
+export declare class LoggerController extends ViewController {
+    #private;
+    protected onConnect(el: HTMLElement): void;
+}
+export declare class Logger {
+    #private;
+    error(...data: any[]): boolean;
+    warn(...data: any[]): boolean;
+    info(...data: any[]): boolean;
+    debug(...data: any[]): boolean;
+    errorGroup(title: string): GroupedLog;
+    warnGroup(title: string): GroupedLog;
+    infoGroup(title: string): GroupedLog;
+    debugGroup(title: string): GroupedLog;
+    setTarget(newTarget: EventTarget | null): void;
+    dispatch(level: LogLevel, ...data: any[]): boolean;
+}

package/types/foundation/logger/events.d.ts

@@ -0,0 +1,26 @@
+import type { DOMEvent } from 'maverick.js/std';
+import type { LogLevel } from './log-level';
+declare global {
+    interface HTMLElementEventMap extends LoggerEvents {
+    }
+}
+export interface LoggerEvents {
+    'vds-log': LogEvent;
+}
+export interface LogEventDetail {
+    /**
+     * The log level.
+     */
+    level: LogLevel;
+    /**
+     * Data to be logged.
+     */
+    data?: any[];
+}
+/**
+ * @bubbles
+ * @composed
+ * @detail log
+ */
+export interface LogEvent extends DOMEvent<LogEventDetail> {
+}

package/types/foundation/logger/grouped-log.d.ts

@@ -0,0 +1,22 @@
+import type { Logger } from './controller';
+import type { LogLevel } from './log-level';
+export declare const GROUPED_LOG: unique symbol;
+export declare class GroupedLog {
+    readonly logger: Logger;
+    readonly level: LogLevel;
+    readonly title: string;
+    readonly root?: GroupedLog | undefined;
+    readonly parent?: GroupedLog | undefined;
+    readonly [GROUPED_LOG] = true;
+    readonly logs: ({
+        label?: string;
+        data: any[];
+    } | GroupedLog)[];
+    constructor(logger: Logger, level: LogLevel, title: string, root?: GroupedLog | undefined, parent?: GroupedLog | undefined);
+    log(...data: any[]): GroupedLog;
+    labelledLog(label: string, ...data: any[]): GroupedLog;
+    groupStart(title: string): GroupedLog;
+    groupEnd(): GroupedLog;
+    dispatch(): boolean;
+}
+export declare function isGroupedLog(data: any): data is GroupedLog;

package/types/foundation/logger/log-level.d.ts

@@ -0,0 +1,15 @@
+export type LogLevel = 'silent' | 'error' | 'warn' | 'info' | 'debug';
+export declare const LogLevelValue: Readonly<{
+    silent: 0;
+    error: 1;
+    warn: 2;
+    info: 3;
+    debug: 4;
+}>;
+export declare const LogLevelColor: Readonly<{
+    silent: "white";
+    error: "hsl(6, 58%, 50%)";
+    warn: "hsl(51, 58%, 50%)";
+    info: "hsl(219, 58%, 50%)";
+    debug: "hsl(280, 58%, 50%)";
+}>;

package/types/foundation/logger/log-printer.d.ts

@@ -0,0 +1,11 @@
+import { ViewController } from 'maverick.js';
+import { type LogLevel } from './log-level';
+export declare class LogPrinter extends ViewController {
+    #private;
+    /**
+     * The current log level.
+     */
+    get logLevel(): LogLevel;
+    set logLevel(level: LogLevel);
+    protected onConnect(): void;
+}

package/types/foundation/logger/ms.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @see https://github.com/vercel/ms
+ */
+export declare function ms(val: number): string;

package/types/foundation/observers/focus-visible.d.ts

@@ -0,0 +1,7 @@
+import { ViewController } from 'maverick.js';
+export declare let $keyboard: import("maverick.js").WriteSignal<boolean>;
+export declare class FocusVisibleController extends ViewController {
+    #private;
+    protected onConnect(el: HTMLElement): void;
+    focused(): boolean;
+}

package/types/foundation/observers/intersection-observer.d.ts

@@ -0,0 +1,36 @@
+import { ViewController } from 'maverick.js';
+export declare class IntersectionObserverController extends ViewController {
+    #private;
+    constructor(init: IntersectionObserverInit);
+    protected onConnect(el: HTMLElement): void;
+}
+export interface IntersectionObserverInit {
+    /**
+     * The element that is used as the viewport for checking visibility of the target. Must be the
+     * ancestor of the target. Defaults to the browser viewport if not specified or if `null`.
+     */
+    root?: Element | Document | null;
+    /**
+     * Margin around the root. Can have values similar to the CSS margin property, e.g.
+     * "10px 20px 30px 40px" (top, right, bottom, left). The values can be percentages. This set
+     * of values serves to grow or shrink each side of the root element's bounding box before
+     * computing intersections. Defaults to all zeros.
+     */
+    rootMargin?: string;
+    /**
+     * Either a single number or an array of numbers which indicate at what percentage of the
+     * target's visibility the observer's callback should be executed. If you only want to detect
+     * when visibility passes the `50%` mark, you can use a value of `0.5`. If you want the callback
+     * to run every time visibility passes another `25%`, you would specify the array
+     * `[0, 0.25, 0.5, 0.75, 1]`.
+     *
+     * The default is `0` (meaning as soon as even one pixel is visible, the callback will be run).
+     * A value of `1.0` means that the threshold isn't considered passed until every pixel is
+     * visible.
+     */
+    threshold?: number | number[];
+    /**
+     * Invoked when an intersection event occurs.
+     */
+    callback?: IntersectionObserverCallback;
+}

package/types/foundation/observers/page-visibility.d.ts

@@ -0,0 +1,37 @@
+declare global {
+    interface GlobalEventHandlersEventMap {
+        beforeunload: Event;
+        pageshow: Event;
+        pagehide: Event;
+        visibilitychange: Event;
+    }
+}
+export declare class PageVisibility {
+    #private;
+    connect(): void;
+    /**
+     * The current page state. Important to note we only account for a subset of page states, as
+     * the rest aren't valuable to the player at the moment.
+     *
+     * - **active:** A page is in the active state if it is visible and has input focus.
+     * - **passive:** A page is in the passive state if it is visible and does not have input focus.
+     * - **hidden:** A page is in the hidden state if it is not visible.
+     *
+     * @see https://developers.google.com/web/updates/2018/07/page-lifecycle-api#states
+     */
+    get pageState(): PageState;
+    /**
+     * The current document visibility state.
+     *
+     * - **visible:** The page content may be at least partially visible. In practice, this means that
+     * the page is the foreground tab of a non-minimized window.
+     * - **hidden:** The page content is not visible to the user. In practice this means that the
+     * document is either a background tab or part of a minimized window, or the OS screen lock is
+     * active.
+     *
+     * @see https://developer.mozilla.org/en-US/docs/Web/API/Document/visibilityState
+     */
+    get visibility(): DocumentVisibility;
+}
+export type PageState = 'active' | 'passive' | 'hidden';
+export type DocumentVisibility = 'visible' | 'hidden';

package/types/foundation/observers/raf-loop.d.ts

@@ -0,0 +1,6 @@
+export declare class RAFLoop {
+    #private;
+    constructor(callback: () => void);
+    start(): void;
+    stop(): void;
+}

package/types/foundation/orientation/controller.d.ts

@@ -0,0 +1,62 @@
+import { ViewController } from 'maverick.js';
+import type { ScreenOrientationEvents } from './events';
+import type { ScreenOrientationLockType, ScreenOrientationType } from './types';
+export declare class ScreenOrientationController extends ViewController<{}, {}, ScreenOrientationEvents> {
+    #private;
+    /**
+     * The current screen orientation type.
+     *
+     * @signal
+     * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/ScreenOrientation}
+     * @see https://w3c.github.io/screen-orientation/#screen-orientation-types-and-locks
+     */
+    get type(): ScreenOrientationType | undefined;
+    /**
+     * Whether the screen orientation is currently locked.
+     *
+     * @signal
+     * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/ScreenOrientation}
+     * @see https://w3c.github.io/screen-orientation/#screen-orientation-types-and-locks
+     */
+    get locked(): boolean;
+    /**
+     * Whether the viewport is in a portrait orientation.
+     *
+     * @signal
+     */
+    get portrait(): boolean;
+    /**
+     * Whether the viewport is in a landscape orientation.
+     *
+     * @signal
+     */
+    get landscape(): boolean;
+    /**
+     * Whether the native Screen Orientation API is available.
+     */
+    static readonly supported: boolean;
+    /**
+     * Whether the native Screen Orientation API is available.
+     */
+    get supported(): boolean;
+    protected onConnect(): void;
+    /**
+     * Locks the orientation of the screen to the desired orientation type using the
+     * Screen Orientation API.
+     *
+     * @param lockType - The screen lock orientation type.
+     * @throws Error - If screen orientation API is unavailable.
+     * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/Screen/orientation}
+     * @see {@link https://w3c.github.io/screen-orientation}
+     */
+    lock(lockType: ScreenOrientationLockType): Promise<void>;
+    /**
+     * Unlocks the orientation of the screen to it's default state using the Screen Orientation
+     * API. This method will throw an error if the API is unavailable.
+     *
+     * @throws Error - If screen orientation API is unavailable.
+     * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/Screen/orientation}
+     * @see {@link https://w3c.github.io/screen-orientation}
+     */
+    unlock(): Promise<void>;
+}

package/types/foundation/orientation/events.d.ts

@@ -0,0 +1,16 @@
+import type { DOMEvent } from 'maverick.js/std';
+import type { ScreenOrientationLockType, ScreenOrientationType } from './types';
+export interface ScreenOrientationEvents {
+    'orientation-change': ScreenOrientationChangeEvent;
+}
+export interface ScreenOrientationChangeEventDetail {
+    orientation: ScreenOrientationType;
+    lock?: ScreenOrientationLockType;
+}
+/**
+ * Fired when the current screen orientation changes.
+ *
+ * @detail orientation
+ */
+export interface ScreenOrientationChangeEvent extends DOMEvent<ScreenOrientationChangeEventDetail> {
+}

package/types/foundation/orientation/types.d.ts

@@ -0,0 +1,85 @@
+export type ScreenOrientationType = 
+/**
+ * Landscape-primary is an orientation where the screen width is greater than the screen height.
+ * If the device's natural orientation is landscape, then it is in landscape-primary when held
+ * in that position. If the device's natural orientation is portrait, the user agent sets
+ * landscape-primary from the two options as shown in the screen orientation values table.
+ */
+'landscape-primary'
+/**
+ * Landscape-secondary is an orientation where the screen width is greater than the screen
+ * height. If the device's natural orientation is landscape, it is in landscape-secondary when
+ * rotated 180º from its natural orientation. If the device's natural orientation is portrait,
+ * the user agent sets landscape-secondary from the two options as shown in the screen
+ * orientation values table.
+ */
+ | 'landscape-secondary'
+/**
+ * Portrait-primary is an orientation where the screen width is less than or equal to the screen
+ * height. If the device's natural orientation is portrait, then it is in portrait-primary when
+ * held in that position. If the device's natural orientation is landscape, the user agent sets
+ * portrait-primary from the two options as shown in the screen orientation values table.
+ */
+ | 'portrait-primary'
+/**
+ * Portrait-secondary is an orientation where the screen width is less than or equal to the
+ * screen height. If the device's natural orientation is portrait, then it is in
+ * portrait-secondary when rotated 180º from its natural position. If the device's natural
+ * orientation is landscape, the user agent sets portrait-secondary from the two options as
+ * shown in the screen orientation values table.
+ */
+ | 'portrait-secondary';
+export type ScreenOrientationLockType = 
+/**
+ * Any is an orientation that means the screen can be locked to any one of portrait-primary,
+ * portrait-secondary, landscape-primary and landscape-secondary.
+ */
+'any'
+/**
+ * Landscape is an orientation where the screen width is greater than the screen height and
+ * depending on platform convention locking the screen to landscape can represent
+ * landscape-primary, landscape-secondary or both.
+ */
+ | 'landscape'
+/**
+ * Landscape-primary is an orientation where the screen width is greater than the screen height.
+ * If the device's natural orientation is landscape, then it is in landscape-primary when held
+ * in that position. If the device's natural orientation is portrait, the user agent sets
+ * landscape-primary from the two options as shown in the screen orientation values table.
+ */
+ | 'landscape-primary'
+/**
+ * Landscape-secondary is an orientation where the screen width is greater than the screen
+ * height. If the device's natural orientation is landscape, it is in landscape-secondary when
+ * rotated 180º from its natural orientation. If the device's natural orientation is portrait,
+ * the user agent sets landscape-secondary from the two options as shown in the screen
+ * orientation values table.
+ */
+ | 'landscape-secondary'
+/**
+ * Natural is an orientation that refers to either portrait-primary or landscape-primary
+ * depending on the device's usual orientation. This orientation is usually provided by the
+ * underlying operating system.
+ */
+ | 'natural'
+/**
+ * Portrait is an orientation where the screen width is less than or equal to the screen height
+ * and depending on platform convention locking the screen to portrait can represent
+ * portrait-primary, portrait-secondary or both.
+ */
+ | 'portrait'
+/**
+ * Portrait-primary is an orientation where the screen width is less than or equal to the screen
+ * height. If the device's natural orientation is portrait, then it is in portrait-primary when
+ * held in that position. If the device's natural orientation is landscape, the user agent sets
+ * portrait-primary from the two options as shown in the screen orientation values table.
+ */
+ | 'portrait-primary'
+/**
+ * Portrait-secondary is an orientation where the screen width is less than or equal to the
+ * screen height. If the device's natural orientation is portrait, then it is in
+ * portrait-secondary when rotated 180º from its natural position. If the device's natural
+ * orientation is landscape, the user agent sets portrait-secondary from the two options as
+ * shown in the screen orientation values table.
+ */
+ | 'portrait-secondary';

package/types/foundation/queue/queue.d.ts

@@ -0,0 +1,24 @@
+export declare class Queue<Items> {
+    #private;
+    /**
+     * Queue the given `item` under the given `key` to be processed at a later time by calling
+     * `serve(key)`.
+     */
+    enqueue<T extends keyof Items>(key: T, item: Items[T]): void;
+    /**
+     * Process item in queue for the given `key`.
+     */
+    serve<T extends keyof Items>(key: T): Items[T] | undefined;
+    /**
+     * Peek at item in queue for the given `key`.
+     */
+    peek<T extends keyof Items>(key: T): Items[T] | undefined;
+    /**
+     * Removes queued item under the given `key`.
+     */
+    delete(key: keyof Items): void;
+    /**
+     * Clear all items in the queue.
+     */
+    clear(): void;
+}

package/types/foundation/queue/request-queue.d.ts

@@ -0,0 +1,42 @@
+export declare class RequestQueue {
+    #private;
+    /**
+     * The number of callbacks that are currently in queue.
+     */
+    get size(): number;
+    /**
+     * Whether items in the queue are being served immediately, otherwise they're queued to
+     * be processed later.
+     */
+    get isServing(): boolean;
+    /**
+     * Waits for the queue to be flushed (ie: start serving).
+     */
+    waitForFlush(): Promise<void>;
+    /**
+     * Queue the given `callback` to be invoked at a later time by either calling the `serve()` or
+     * `start()` methods. If the queue has started serving (i.e., `start()` was already called),
+     * then the callback will be invoked immediately.
+     *
+     * @param key - Uniquely identifies this callback so duplicates are ignored.
+     * @param callback - The function to call when this item in the queue is being served.
+     */
+    enqueue(key: string | symbol, callback: () => void): void;
+    /**
+     * Invokes the callback with the given `key` in the queue (if it exists).
+     */
+    serve(key: string | symbol): void;
+    /**
+     * Flush all queued items and start serving future requests immediately until `stop()` is called.
+     */
+    start(): void;
+    /**
+     * Stop serving requests, they'll be queued until you begin processing again by calling `start()`.
+     */
+    stop(): void;
+    /**
+     * Stop serving requests, empty the request queue, and release any promises waiting for the
+     * queue to flush.
+     */
+    reset(): void;
+}

package/types/global/layouts/default.d.ts

@@ -0,0 +1,9 @@
+import type { DefaultLayoutProps } from '../../components/layouts/default/props';
+import type { VidstackPlayerLayoutLoader } from './loader';
+export declare class VidstackPlayerLayout implements VidstackPlayerLayoutLoader {
+    readonly props?: Partial<DefaultLayoutProps> | undefined;
+    constructor(props?: Partial<DefaultLayoutProps> | undefined);
+    readonly name = "vidstack";
+    load(): Promise<void>;
+    create(): (import("../../elements").MediaAudioLayoutElement | import("../../elements").MediaVideoLayoutElement)[];
+}

package/types/global/layouts/loader.d.ts

@@ -0,0 +1,5 @@
+export interface VidstackPlayerLayoutLoader {
+    readonly name: string;
+    load(): void | Promise<void>;
+    create(): HTMLElement[] | Promise<HTMLElement[]>;
+}

package/types/global/layouts/plyr.d.ts

@@ -0,0 +1,9 @@
+import type { PlyrLayoutProps } from '../../components/layouts/plyr/props';
+import type { VidstackPlayerLayoutLoader } from './loader';
+export declare class PlyrLayout implements VidstackPlayerLayoutLoader {
+    readonly props?: Partial<PlyrLayoutProps> | undefined;
+    constructor(props?: Partial<PlyrLayoutProps> | undefined);
+    readonly name = "plyr";
+    load(): Promise<void>;
+    create(): import("../../elements").MediaPlyrLayoutElement[];
+}

package/types/global/player.d.ts

@@ -0,0 +1,26 @@
+import '../elements/bundles/player';
+import type { MediaPlayerProps } from '../core/api/player-props';
+import type { TextTrackInit } from '../core/tracks/text/text-track';
+import { VidstackPlayerLayout } from './layouts/default';
+import type { VidstackPlayerLayoutLoader } from './layouts/loader';
+import { PlyrLayout } from './layouts/plyr';
+export declare class VidstackPlayer {
+    static create({ target, layout, tracks, ...props }: VidstackPlayerConfig): Promise<import("../elements").MediaPlayerElement>;
+}
+export type VidstackPlayerTarget = string | HTMLElement;
+export interface VidstackPlayerConfig extends Partial<MediaPlayerProps> {
+    /**
+     * A document query selector string or `HTMLElement` to mount on. If an `<audio>`, `<video>`, or
+     * `<iframe>` element is given it will be enhanced.
+     */
+    target: VidstackPlayerTarget;
+    /**
+     * Text tracks to be included on initialization.
+     */
+    tracks?: TextTrackInit[];
+    /**
+     * Specify a layout to be loaded.
+     */
+    layout?: VidstackPlayerLayoutLoader;
+}
+export { VidstackPlayerLayout, PlyrLayout, type VidstackPlayerLayoutLoader };