@fusion.dev/helix-headless 0.56.0 → 0.57.0

package/dist/video/root/idle.d.ts

@@ -1,34 +0,0 @@
-import type { ReactiveController, ReactiveControllerHost } from 'lit';
-/**
- * How long the reader has been still, which decides when the bar goes.
- *
- * A wait rather than leaving with the pointer, or a reader moving across the
- * picture to reach a control watches the bar vanish under them. The wait is
- * only ever about *idling*: whether a paused video keeps its bar is the
- * element's decision, and this only says when the reader stopped.
- *
- * The delay is asked for on every restart rather than taken once, because it
- * is a property the consumer can change while the video plays.
- */
-export declare class IdleController implements ReactiveController {
-    private readonly delay;
-    private readonly report;
-    private timer;
-    constructor(host: ReactiveControllerHost, delay: () => number, report: (idle: boolean) => void);
-    /**
-     * Restarts the wait, on anything that counts as the reader being here.
-     *
-     * Pointer movement and focus both count, and both have to: a reader using the
-     * keyboard never moves a pointer, and a bar that only answered the mouse
-     * would leave them nothing to look at. Zero turns the wait off and the bar
-     * goes immediately; a large number keeps it up for as long as anyone is
-     * likely to look.
-     */
-    readonly stir: () => void;
-    /**
-     * Leaving is the one case that does not wait: the reader has gone somewhere
-     * else, and there is nothing to reach for.
-     */
-    readonly leave: () => void;
-    hostDisconnected(): void;
-}

package/dist/video/root/idle.js

@@ -1,24 +0,0 @@
-export class IdleController {
-    constructor(host, delay, report) {
-        this.delay = delay;
-        this.report = report;
-        this.stir = () => {
-            this.report(false);
-            clearTimeout(this.timer);
-            const delay = this.delay();
-            if (delay > 0) {
-                this.timer = setTimeout(() => {
-                    this.report(true);
-                }, delay);
-            }
-        };
-        this.leave = () => {
-            clearTimeout(this.timer);
-            this.report(true);
-        };
-        host.addController(this);
-    }
-    hostDisconnected() {
-        clearTimeout(this.timer);
-    }
-}

package/dist/video/root/media-session.d.ts

@@ -1,54 +0,0 @@
-import type { ReactiveController, ReactiveControllerHost } from 'lit';
-/**
- * How far a skip control moves, in seconds.
- *
- * Ten, which is the number every player that has one uses, and the number the
- * platform names in `seekbackward` and `seekforward` when it hands over a
- * default. A different length here would be correct only on this player.
- */
-export declare const SKIP_SECONDS = 10;
-/** What a headset's buttons do, handed over by the player that owns them. */
-export interface SessionHandlers {
-    /**
-     * Asks for the next item, or `null` where the consumer has named nothing to
-     * skip to: the platform draws the key from whether a handler is set.
-     */
-    next: (() => void) | null;
-    /** And the previous one, under the same rule. */
-    previous: (() => void) | null;
-    seek: (seconds: number) => void;
-    skipBy: (seconds: number) => void;
-    toggle: () => void;
-}
-/**
- * Holds the page's media session for one player, and tells the platform what
- * is playing.
- *
- * The handlers are what make a headset's play, pause and skip work at all.
- * Without them a platform falls back to guessing which element was meant,
- * which is right often enough to hide the fault and wrong exactly when there
- * are two.
- */
-export declare class MediaSessionController implements ReactiveController {
-    private readonly host;
-    constructor(host: ReactiveControllerHost & HTMLElement);
-    /**
-     * Takes the session.
-     *
-     * On play rather than on render, which is the ownership rule: a page with two
-     * players gives the session to whichever one the reader started, so a
-     * headset's buttons land on what they are listening to rather than on
-     * whichever came first in the markup.
-     */
-    claim(metadata: {
-        artwork: string;
-        title: string;
-    }, handlers: SessionHandlers): void;
-    /** Tells the platform whether the owner is playing, and nothing if it is not the owner. */
-    report(playing: boolean): void;
-    /**
-     * The page's one media session goes back to nobody, but only if this
-     * element is the one holding it.
-     */
-    hostDisconnected(): void;
-}

package/dist/video/root/media-session.js

@@ -1,49 +0,0 @@
-let owner;
-export const SKIP_SECONDS = 10;
-export class MediaSessionController {
-    constructor(host) {
-        this.host = host;
-        host.addController(this);
-    }
-    claim(metadata, handlers) {
-        if (typeof navigator === 'undefined' || !navigator.mediaSession) {
-            return;
-        }
-        owner = this.host;
-        const session = navigator.mediaSession;
-        session.metadata = new MediaMetadata({
-            artwork: metadata.artwork === '' ? [] : [{ src: metadata.artwork }],
-            title: metadata.title,
-        });
-        session.setActionHandler('play', handlers.toggle);
-        session.setActionHandler('pause', handlers.toggle);
-        session.setActionHandler('seekto', (details) => {
-            if (details.seekTime !== undefined && details.seekTime !== null) {
-                handlers.seek(details.seekTime);
-            }
-        });
-        session.setActionHandler('seekbackward', (details) => {
-            handlers.skipBy(-(details.seekOffset ?? SKIP_SECONDS));
-        });
-        session.setActionHandler('seekforward', (details) => {
-            handlers.skipBy(details.seekOffset ?? SKIP_SECONDS);
-        });
-        session.setActionHandler('nexttrack', handlers.next);
-        session.setActionHandler('previoustrack', handlers.previous);
-    }
-    report(playing) {
-        if (owner === this.host && typeof navigator !== 'undefined' && navigator.mediaSession) {
-            navigator.mediaSession.playbackState = playing ? 'playing' : 'paused';
-        }
-    }
-    hostDisconnected() {
-        if (owner !== this.host) {
-            return;
-        }
-        owner = undefined;
-        if (typeof navigator !== 'undefined' && navigator.mediaSession) {
-            navigator.mediaSession.metadata = null;
-            navigator.mediaSession.playbackState = 'none';
-        }
-    }
-}

package/dist/video/root/remote-playback.d.ts

@@ -1,34 +0,0 @@
-import type { ReactiveController, ReactiveControllerHost } from 'lit';
-/** What the watch reports, as it learns it. */
-export interface RemoteReport {
-    /** Whether anything on the network offers to play this. */
-    available: (available: boolean) => void;
-    /** Whether it is playing somewhere else right now. */
-    connected: (connected: boolean) => void;
-}
-/**
- * Watches for something to play the video on, and stops on the way out.
- *
- * The Remote Playback API is the standard one, and it is what Safari
- * implements for AirPlay and Chrome for Cast: one call covers both, where the
- * older `webkitShowPlaybackTargetPicker` covers only the first. Firefox has
- * neither, and `remote` simply being absent is what turns the control off
- * there.
- *
- * `watchAvailability` returns an id that has to be canceled, or the callback
- * outlives the element that owns it: a callback holding a removed element is a
- * leak with a `@state` write on the end.
- */
-export declare class RemotePlaybackController implements ReactiveController {
-    private readonly report;
-    private video;
-    /** Cancels the availability watch, since it outlives a single render. */
-    private watch;
-    constructor(host: ReactiveControllerHost, report: RemoteReport);
-    /** Starts watching the video, once there is one. */
-    attach(video: HTMLVideoElement): Promise<void>;
-    /** Opens the platform's own device picker. It has no list of its own. */
-    prompt(): Promise<void>;
-    hostDisconnected(): void;
-    private readonly handleState;
-}

package/dist/video/root/remote-playback.js

@@ -1,38 +0,0 @@
-export class RemotePlaybackController {
-    constructor(host, report) {
-        this.report = report;
-        this.handleState = () => {
-            this.report.connected(this.video?.remote?.state === 'connected');
-        };
-        host.addController(this);
-    }
-    async attach(video) {
-        this.video = video;
-        video.remote?.addEventListener?.('connect', this.handleState);
-        video.remote?.addEventListener?.('disconnect', this.handleState);
-        const remote = video.remote;
-        if (!remote?.watchAvailability) {
-            return;
-        }
-        try {
-            this.watch = await remote.watchAvailability((available) => {
-                this.report.available(available);
-            });
-        }
-        catch {
-        }
-    }
-    async prompt() {
-        try {
-            await this.video?.remote?.prompt();
-        }
-        catch {
-        }
-    }
-    hostDisconnected() {
-        if (this.watch !== undefined) {
-            void this.video?.remote?.cancelWatchAvailability?.(this.watch);
-            this.watch = undefined;
-        }
-    }
-}