@amazon/vinyl 1.0.0

package/dist/types/current/patch/media/patches/createUnreliablePlaybackEventsPatch.js

@@ -0,0 +1,218 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Browser, hasBrowser } from '@amazon/vinyl-util';
+import { closeTo, createDisposer, DomEventHost, onAny, SignalImpl, } from '@amazon/vinyl-util';
+/**
+ * The interval (in seconds) to poll for time progress in a media element.
+ *
+ * @private
+ */
+export const UNRELIABLE_EVENTS_POLL_INTERVAL = 0.2;
+/**
+ * Minimum amount of time playback must be stalled before fabricating a waiting event.
+ */
+export const MIN_STALLED_BEFORE_FAB = 0.8;
+/**
+ * Minimum amount of time playback must be progressing before fabricating a playing event.
+ */
+export const MIN_PLAYING_BEFORE_FAB = 0.4;
+/**
+ * If currentTime does not change larger than this value, it will be considered to be stalled.
+ */
+const MIN_PLAYING_DELTA = 0.05;
+/**
+ * If currentTime changes beyond this tolerance the apparent state will be considered to be seeking.
+ */
+const MIN_SEEKING_DELTA = 0.5;
+var PlayHeadState;
+(function (PlayHeadState) {
+    /**
+     * The last time update was an increment from the previous.
+     */
+    PlayHeadState[PlayHeadState["PLAYING"] = 0] = "PLAYING";
+    /**
+     * The last time update was close to the previous.
+     */
+    PlayHeadState[PlayHeadState["STOPPED"] = 1] = "STOPPED";
+    /**
+     * The last time update was a non-incremental change.
+     */
+    PlayHeadState[PlayHeadState["SEEKING"] = 2] = "SEEKING";
+})(PlayHeadState || (PlayHeadState = {}));
+/**
+ * Playback events such as playing, canPlay, and waiting are unreliable on this platform.
+ * Watch playback state and fabricate events when necessary.
+ */
+export function createUnreliablePlaybackEventsPatch(media) {
+    const { add, dispose } = createDisposer();
+    const domEvents = add(new DomEventHost(media));
+    const eventFabricated = add(new SignalImpl());
+    // The timestamp of the last change.
+    let stateChangedAt = Date.now();
+    // The current observed state based on the play head progress.
+    let currentApparentState = PlayHeadState.STOPPED;
+    /**
+     * @param state The new apparent state.
+     * @param changedAt The timestamp the apparent state was changed.
+     */
+    function setApparentState(state, changedAt = Date.now()) {
+        if (currentApparentState !== state) {
+            currentApparentState = state;
+            stateChangedAt = changedAt;
+        }
+    }
+    /**
+     * Returns the number of seconds since the last state change.
+     */
+    function elapsedStateTime() {
+        return (Date.now() - stateChangedAt) / 1000;
+    }
+    let lastTimestamp = Date.now();
+    let lastTime = media.currentTime;
+    let waiting = false;
+    let seeking = false;
+    onAny(domEvents, ['emptied', 'ended', 'pause', 'playing', 'seeking'], () => {
+        waiting = false;
+    });
+    let playing = false;
+    onAny(domEvents, ['emptied', 'ended', 'pause', 'seeking', 'waiting'], () => {
+        playing = false;
+    });
+    domEvents.on('seeking', () => {
+        seeking = true;
+    });
+    domEvents.on('seeked', () => {
+        seeking = false;
+        setApparentState(PlayHeadState.SEEKING);
+    });
+    domEvents.on('play', () => {
+        // Resets the timer so that the !paused state does not immediately trigger a 'waiting' event.
+        stateChangedAt = Date.now();
+    });
+    // All events that can affect the ready state.
+    // canplay and canplaythrough are handled in the overridden events map.
+    const readyStateEvents = [
+        'emptied',
+        'loadeddata',
+        'loadedmetadata',
+        'waiting',
+    ];
+    let lastReadyStateEvent = 'emptied';
+    add(onAny(domEvents, readyStateEvents, (_, type) => {
+        lastReadyStateEvent = type;
+    }));
+    const checkApparentState = () => {
+        const progressed = (media.currentTime - lastTime) / media.playbackRate;
+        const now = Date.now();
+        if (Math.abs(progressed) > MIN_SEEKING_DELTA) {
+            setApparentState(PlayHeadState.SEEKING, lastTimestamp);
+        }
+        else if (progressed >= MIN_PLAYING_DELTA) {
+            setApparentState(PlayHeadState.PLAYING, lastTimestamp);
+        }
+        else if (closeTo(progressed, 0, MIN_PLAYING_DELTA)) {
+            setApparentState(PlayHeadState.STOPPED, lastTimestamp);
+        }
+        lastTime = media.currentTime;
+        lastTimestamp = now;
+        if (!playing &&
+            !seeking &&
+            !media.paused &&
+            !media.ended &&
+            media.readyState >= media.HAVE_FUTURE_DATA &&
+            currentApparentState === PlayHeadState.PLAYING &&
+            elapsedStateTime() >= MIN_PLAYING_BEFORE_FAB) {
+            // The play head is progressing but a playing event was never observed.
+            waiting = false;
+            playing = true;
+            if (lastReadyStateEvent !== 'canplay' &&
+                lastReadyStateEvent !== 'canplaythrough') {
+                lastReadyStateEvent = 'canplay';
+                eventFabricated.dispatch(new CustomEvent('canplay'));
+            }
+            if (media.readyState >= media.HAVE_ENOUGH_DATA) {
+                if (lastReadyStateEvent !== 'canplaythrough') {
+                    lastReadyStateEvent = 'canplaythrough';
+                    eventFabricated.dispatch(new CustomEvent('canplaythrough'));
+                }
+            }
+            eventFabricated.dispatch(new CustomEvent('playing'));
+        }
+        if (!waiting &&
+            !media.paused &&
+            !media.ended &&
+            currentApparentState === PlayHeadState.STOPPED &&
+            elapsedStateTime() >= MIN_STALLED_BEFORE_FAB) {
+            waiting = true;
+            playing = false;
+            // currentTime is not changing; playback has stopped but no 'waiting' event
+            // was observed.
+            eventFabricated.dispatch(new CustomEvent('waiting'));
+        }
+    };
+    const playbackWatchIntervalId = setInterval(checkApparentState, UNRELIABLE_EVENTS_POLL_INTERVAL * 1000);
+    add(() => {
+        clearInterval(playbackWatchIntervalId);
+    });
+    return {
+        eventFabricated,
+        properties: {
+            /**
+             * Platforms that have unreliable waiting events, also have unreliable ready state
+             * when the end of buffered data has been reached. If the media is in a waiting state,
+             * the highest ready state that is possible is HAVE_METADATA.
+             */
+            readyState: {
+                get() {
+                    return waiting
+                        ? Math.min(media.readyState, media.HAVE_METADATA)
+                        : media.readyState;
+                },
+            },
+        },
+        events: {
+            canplay(event) {
+                // Do not emit the canplay event if one was fabricated.
+                const eventOrNull = lastReadyStateEvent === 'canplay' ? null : event;
+                lastReadyStateEvent = 'canplay';
+                return eventOrNull;
+            },
+            canplaythrough(event) {
+                // Do not emit the canplaythrough event if one was fabricated.
+                const eventOrNull = lastReadyStateEvent === 'canplaythrough' ? null : event;
+                lastReadyStateEvent = 'canplaythrough';
+                return eventOrNull;
+            },
+            playing(event) {
+                if (playing) {
+                    // Do not emit the playing event if one was fabricated.
+                    return null;
+                }
+                setApparentState(PlayHeadState.PLAYING);
+                playing = true;
+                return event;
+            },
+            waiting(event) {
+                if (waiting) {
+                    // Do not emit the waiting event if one was fabricated.
+                    return null;
+                }
+                waiting = true;
+                setApparentState(PlayHeadState.STOPPED);
+                return event;
+            },
+        },
+        dispose,
+    };
+}
+/**
+ * Chrome <= 53 has unreliable waiting events.
+ * Safari, and Edge Legacy miss playing events after seeking.
+ */
+export function requiresUnreliablePlaybackEventsPatch() {
+    return (hasBrowser(Browser.SAFARI) ||
+        hasBrowser(Browser.EDGE_LEGACY) ||
+        hasBrowser(Browser.CHROMIUM, null, '53'));
+}

package/dist/types/current/playback/PlaybackController.d.ts

@@ -0,0 +1,56 @@
+import type { ReadonlyPlaybackController } from './ReadonlyPlaybackController';
+export interface PlaybackController extends ReadonlyPlaybackController {
+    defaultPlaybackRate: number;
+    loop: boolean;
+    muted: boolean;
+    playbackRate: number;
+    preservesPitch: boolean;
+    volume: number;
+    /**
+     * Pauses playback of the media, if the media is already in a paused state
+     * this method will have no effect.
+     * If a play is pending, the play will be aborted and the promise returned by play() will be
+     * rejected.
+     *
+     * @see pendingPlay
+     * @see play
+     */
+    pause(): void;
+    /**
+     * Attempts to begin playback of the media. It returns a Promise which is resolved when
+     * playback has been successfully started.
+     *
+     * Failure to begin playback for any reason, such as permission issues or interruption via
+     * pause, results in the promise being rejected.
+     *
+     * The first time play() is invoked, except muted video, should be in response to a user
+     * interaction such as a button click.
+     *
+     * @see isNotAllowedError
+     */
+    play(): Promise<void>;
+    /**
+     * Safely seeks to the given time.
+     * The seek will begin only after {@link readyState} is at least
+     * {@link PlaybackReadyState.HAVE_METADATA}.
+     * If a previous seek was still pending, the previous seek will be ignored.
+     * Returns a Promise that resolves when the seek has completed. If the seek is interrupted
+     * by another seek, the promise will be rejected with an `AbortError`.
+     * If the seek is not to a seekable range, the promise will reject with an {@link InvalidSeekError}.
+     *
+     * @param time The value, in seconds, to set the playback time.
+     * @param tolerance The amount of tolerance to have when the time is outside the seekable
+     * ranges to snap, in seconds. If time is outside all seekable ranges beyond this tolerance,
+     * the seek will be ignored. Default: 0.5
+     */
+    seekTo(time: number, tolerance?: number): Promise<void>;
+    /**
+     * Resets the error state.
+     */
+    reset(): void;
+}
+/**
+ * The maximum duration media can be before it is considered 'live'.
+ */
+export declare const LIVE_DURATION = 4294967296;
+//# sourceMappingURL=PlaybackController.d.ts.map

package/dist/types/current/playback/PlaybackController.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PlaybackController.d.ts","sourceRoot":"","sources":["../../../../src/playback/PlaybackController.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,8BAA8B,CAAA;AAE9E,MAAM,WAAW,kBAAmB,SAAQ,0BAA0B;IAClE,mBAAmB,EAAE,MAAM,CAAA;IAC3B,IAAI,EAAE,OAAO,CAAA;IACb,KAAK,EAAE,OAAO,CAAA;IACd,YAAY,EAAE,MAAM,CAAA;IACpB,cAAc,EAAE,OAAO,CAAA;IACvB,MAAM,EAAE,MAAM,CAAA;IAEd;;;;;;;;OAQG;IACH,KAAK,IAAI,IAAI,CAAA;IAEb;;;;;;;;;;;OAWG;IACH,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;IAErB;;;;;;;;;;;;;OAaG;IACH,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IAEvD;;OAEG;IACH,KAAK,IAAI,IAAI,CAAA;CAChB;AAED;;GAEG;AACH,eAAO,MAAM,aAAa,aAAa,CAAA"}

package/dist/types/current/playback/PlaybackController.js

@@ -0,0 +1,8 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * The maximum duration media can be before it is considered 'live'.
+ */
+export const LIVE_DURATION = 4294967296; // 2 ** 32

package/dist/types/current/playback/PlaybackControllerImpl.d.ts

@@ -0,0 +1,181 @@
+import { EventHostImpl, type ReadonlyRanges } from '@amazon/vinyl-util';
+import { type PlaybackController } from './PlaybackController';
+import { type PlaybackControllerEventMap, PlaybackReadyState } from './ReadonlyPlaybackController';
+import type { LoudnessNormalizationController } from '../playback/loudness/LoudnessNormalizationController';
+export interface PlaybackControllerImplOptions {
+    /**
+     * An affordance when comparing the last currentTime and the new currentTime after a seek.
+     * Most browsers have around 30-40 time updates per second, but some constrained devices only
+     * have a few. This value needs to be large enough where the last timeupdate in a looping track
+     * is at currentTime >= duration - LOOP_TIME_AFFORDANCE.
+     * Default: 2
+     */
+    readonly loopTimeAffordance: number;
+    /**
+     * The minimum number of seconds before the end of the next seekable range allowed for a seek
+     * operation. Some browsers will never complete a seek operation if the seek is too close to
+     * this end range.
+     * Default: getMinSeekableBufferDefault() which is between 0.5 and 5, browser dependent.
+     */
+    readonly minSeekableBuffer: number;
+    /**
+     * The number of seconds before the promise returned by play() is rejected regardless whether
+     * the media element response has settled.
+     * Default: 30
+     */
+    readonly playTimeout: number;
+    /**
+     * The number of seconds before the promise returned by seek() is rejected.
+     * Default: 30
+     */
+    readonly seekTimeout: number;
+}
+export declare const defaultPlaybackControllerImplOptions: {
+    readonly loopTimeAffordance: 2;
+    readonly minSeekableBuffer: -1;
+    readonly playTimeout: 30;
+    readonly seekTimeout: 30;
+};
+/**
+ * Safari and Edge Legacy cannot reliably seek close to the end of a seekable range.
+ * Firefox can but if the playhead reaches the end of track before the media stream is closed, an 'ended' event
+ * will never fire.
+ */
+export declare function getMinSeekableBufferDefault(): 2 | 5;
+export interface PlaybackControllerImplDeps {
+    readonly media: HTMLMediaElement;
+    readonly loudnessNormalizationController: LoudnessNormalizationController;
+}
+export declare class PlaybackControllerImpl extends EventHostImpl<PlaybackControllerEventMap> implements PlaybackController {
+    private readonly loudnessNormalizationController;
+    get [Symbol.toStringTag](): string;
+    private _error;
+    private readonly media;
+    private readonly domEvents;
+    private readonly disposer;
+    private _playing;
+    private _seeking;
+    private _waiting;
+    private userVolume;
+    private _pendingPlay;
+    private playAbort;
+    private disposeAbort;
+    readonly options: PlaybackControllerImplOptions;
+    constructor(deps: PlaybackControllerImplDeps, options?: Partial<PlaybackControllerImplOptions>);
+    /**
+     * Updates volume with loudness gain, on the mediaElement.
+     * @private
+     */
+    private refreshVolume;
+    /**
+     * Listens to select events on the media element, redispatching as playback state events.
+     * @private
+     */
+    private initializeEvents;
+    /**
+     * Re-dispatches the plain DOM events without extra information.
+     *
+     * @private
+     */
+    private initializePlainEvents;
+    /**
+     * Delegates the DOM events with additional information about what the previous and current
+     * values are.
+     * @private
+     */
+    private initializeChangeEvents;
+    /**
+     * Operation events provide an easy way to listen for the terminus of a state.
+     * For example after a 'waiting' event, there are several different events that indicate that
+     * the waiting has finished, and this API provides those events conflated into a single
+     * 'waited' event.
+     * @private
+     */
+    private initializeOperationEvents;
+    /**
+     * When going into a state from a beginEvent, dispatches endEvent when any of the endEvents
+     * is dispatched.
+     *
+     * This allows consumers of the playback state to listen for the exit of a state without
+     * needing to know every event that ends that state.
+     *
+     * @param host The event host emitting the primary events.
+     * @param beginEvent The event that enters a state.
+     * @param endEvents A list of events that exits the entered state.
+     * @param onBegin Invoked when the operation has begun.
+     * @param onEnd Invoked when the operation has completed.
+     */
+    private operationEvent;
+    /**
+     * Dispatches a 'mutedChange' event when 'muted' state has changed.
+     *
+     * The DOM element only provides a 'volumeChange' event, which is filtered to watch when
+     * muted has changed.
+     *
+     * @private
+     */
+    private initializeMutedEvent;
+    /**
+     * Dispatches a looped event if loop is true and playback wraps back to the start.
+     * Safari emits timeupdate events at duration and then 0 before the seeking event
+     * Other browsers emit the seeking before the timeupdate near zero.
+     * Firefox timeupdate after the loop is near zero, not exactly.
+     *
+     * @private
+     */
+    private initializeLoopedEvent;
+    get buffered(): ReadonlyRanges;
+    get currentTime(): number;
+    get currentTimePercent(): number;
+    get defaultPlaybackRate(): number;
+    set defaultPlaybackRate(value: number);
+    get duration(): number;
+    get ended(): boolean;
+    get error(): Error | null;
+    get loop(): boolean;
+    set loop(value: boolean);
+    get muted(): boolean;
+    set muted(value: boolean);
+    get networkState(): number;
+    get paused(): boolean;
+    get playbackRate(): number;
+    set playbackRate(value: number);
+    get playing(): boolean;
+    get preservesPitch(): boolean;
+    set preservesPitch(value: boolean);
+    get readyState(): PlaybackReadyState;
+    get seekable(): ReadonlyRanges;
+    get seeking(): boolean;
+    get volume(): number;
+    set volume(value: number);
+    get waiting(): boolean;
+    pause(): void;
+    private get pendingPlay();
+    private set pendingPlay(value);
+    play(): Promise<void>;
+    get canPlay(): boolean;
+    get canPlayThrough(): boolean;
+    get hasMetadata(): boolean;
+    get playIsPending(): boolean;
+    seekTo(time: number, tolerance?: number): Promise<void>;
+    /**
+     * Dispatches a readyStateChange event when {@link readyState} changes.
+     * @private
+     */
+    private initializeReadyStateChangeEvent;
+    reset(): void;
+    /**
+     * True if this controller has been disposed.
+     */
+    get disposed(): boolean;
+    dispose(): void;
+}
+/**
+ * Returns true if the play rejection reason is a not allowed error. This indicates that play
+ * should be retried within a user interaction stack.
+ * @param reason
+ */
+export declare function isNotAllowedError(reason: any): reason is {
+    name: 'NotAllowedError';
+};
+//# sourceMappingURL=PlaybackControllerImpl.d.ts.map

package/dist/types/current/playback/PlaybackControllerImpl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PlaybackControllerImpl.d.ts","sourceRoot":"","sources":["../../../../src/playback/PlaybackControllerImpl.ts"],"names":[],"mappings":"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"}