@amazon/vinyl 1.0.0

package/dist/types/ts4.1/drm/util/extractContentId.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Extract contentId from event data encoded as UTF16.
+ *
+ * @param initData Expected byte array representing a UTF-16 string in the form
+ * `skd://0b5689bb-4171-97e5-c280-99f7abe4004f`
+ */
+export declare function extractContentId(initData: Uint8Array): string;
+//# sourceMappingURL=extractContentId.d.ts.map

package/dist/types/ts4.1/drm/util/unpackPlayReadyChallenge.d.ts

@@ -0,0 +1,46 @@
+import type { ReadonlyRecord } from '@amazon/vinyl-util';
+import type { XmlElement } from '@amazon/vinyl-xml';
+/**
+ * The final challenge buffer and headers for a playready license challenge.
+ */
+export interface UnpackedPlayReadyChallenge {
+    readonly challenge: ArrayBuffer;
+    readonly headers: ReadonlyRecord<string, string>;
+}
+/**
+ * IE and Edge wraps playready license challenges in PlayReadyKeyMessage xml.
+ * Not all PlayReady clients do this.
+ * Checks if the challenge is wrapped, and if so, returns the set headers and unwrapped challenge.
+ * Otherwise, returns the challenge as-is with the required content type header.
+ *
+ * @param challenge The array buffer from the 'message' cdm event.
+ */
+export declare function unpackPlayReadyChallenge(challenge: ArrayBuffer): UnpackedPlayReadyChallenge;
+interface PlayReadyMessage {
+    readonly PlayReadyKeyMessage: PlayReadyKeyMessageType;
+}
+interface PlayReadyKeyMessageType {
+    readonly type?: string;
+    readonly LicenseAcquisition: LicenseAcquisitionType;
+}
+interface LicenseAcquisitionType {
+    readonly Version: number;
+    readonly Challenge: ChallengeType;
+    readonly HttpHeaders: HttpHeadersType;
+}
+interface ContentType {
+    readonly _content: string;
+}
+interface ChallengeType extends ContentType {
+    readonly encoding?: string;
+}
+interface HttpHeadersType {
+    readonly HttpHeader: readonly HttpHeaderType[];
+}
+interface HttpHeaderType {
+    readonly name: ContentType;
+    readonly value: ContentType;
+}
+export declare function parsePlayReadyKeyMessage(xmlStr: string): PlayReadyMessage & XmlElement<PlayReadyMessage>;
+export {};
+//# sourceMappingURL=unpackPlayReadyChallenge.d.ts.map

package/dist/types/ts4.1/event/BasicErrorEvent.d.ts

@@ -0,0 +1,12 @@
+import type { LogTarget } from '@amazon/vinyl-util';
+export interface BasicErrorEvent {
+    /**
+     * The target reporting the error.
+     */
+    readonly target: LogTarget;
+    /**
+     * The error.
+     */
+    readonly error: Error;
+}
+//# sourceMappingURL=BasicErrorEvent.d.ts.map

package/dist/types/ts4.1/event/ChangeEvent.d.ts

@@ -0,0 +1,12 @@
+export interface ChangeEvent<T> {
+    readonly previous: T | null;
+    readonly current: T;
+}
+/**
+ * Creates a function, which when invoked, will call `inner` with a new ChangeEvent.
+ *
+ * @param getter
+ * @param inner
+ */
+export declare function createChangeEventTrigger<T>(getter: () => T, inner: (event: ChangeEvent<T>) => void): () => void;
+//# sourceMappingURL=ChangeEvent.d.ts.map

package/dist/types/ts4.1/global/PlayerRegistry.d.ts

@@ -0,0 +1,52 @@
+import type { AnyRecord, Disposable } from '@amazon/vinyl-util';
+/**
+ * A registry of all non-disposed Vinyl players.
+ * Used for debugging and cleanup validation.
+ */
+export interface PlayerRegistry {
+    /**
+     * Returns the non-disposed Vinyl players.
+     */
+    readonly players: readonly AnyRecord[];
+    /**
+     * Adds a player reference. All players must be removed before disposing VinylGlobal.
+     *
+     * @param player
+     */
+    addPlayer(player: AnyRecord): void;
+    /**
+     * Removes a player reference.
+     *
+     * @param player
+     */
+    removePlayer(player: AnyRecord): void;
+}
+export declare const DEFAULT_MAX_PLAYERS = 5;
+/**
+ * A registry of non-disposed players.
+ * Used for leak detection and debugging diagnostics.
+ */
+export declare class PlayerRegistryImpl implements PlayerRegistry, Disposable {
+    /**
+     * The number of concurrent players before a warning is logged.
+     * default: 5
+     */
+    maxPlayersWarning: number;
+    private _players;
+    private gaveMaxPlayersWarning;
+    constructor(
+    /**
+     * The number of concurrent players before a warning is logged.
+     * default: 5
+     */
+    maxPlayersWarning?: number);
+    get players(): readonly AnyRecord[];
+    addPlayer(player: AnyRecord): void;
+    removePlayer(player: AnyRecord): void;
+    /**
+     * @throws An IllegalStateError if all players have not been removed.
+     */
+    dispose(): void;
+}
+export declare const playerRegistryRef: import("@amazon/vinyl-util").GlobalRef<PlayerRegistry>;
+//# sourceMappingURL=PlayerRegistry.d.ts.map

package/dist/types/ts4.1/global/configureVinylGlobal.d.ts

@@ -0,0 +1,44 @@
+import type { PartialDeep } from '@amazon/vinyl-util';
+import { LogLevel } from '@amazon/vinyl-util';
+/**
+ * Configuration for VinylGlobal.
+ */
+export interface VinylGlobalOptions {
+    /**
+     * The number of concurrent players before a warning is logged.
+     * default: 5
+     */
+    readonly maxPlayersWarning: number;
+    /**
+     * Logging configuration
+     */
+    readonly logging: {
+        readonly history: {
+            /**
+             * Limits the history log level.
+             */
+            readonly logLevel: LogLevel;
+            /**
+             * Sets the logging history size.
+             */
+            readonly maxHistorySize: number;
+        };
+        /**
+         * Gates all log handlers to logs of at least this level.
+         */
+        readonly logLevel: LogLevel;
+        readonly console: {
+            /**
+             * Gates console logs
+             */
+            readonly logLevel: LogLevel;
+        };
+    };
+}
+/**
+ * Applies configuration to the current vinyl global options.
+ *
+ * @param options
+ */
+export declare function configureVinylGlobal(options: PartialDeep<VinylGlobalOptions>): void;
+//# sourceMappingURL=configureVinylGlobal.d.ts.map

package/dist/types/ts4.1/global/environment.d.ts

@@ -0,0 +1,6 @@
+/**
+ * process.env.VINYL_VERSION will be null in node unit tests, but in the built library it is
+ * replaced by the webpack DefinePlugin with the package.version.
+ */
+export declare const vinylVersion: import("@amazon/vinyl-util").Version;
+//# sourceMappingURL=environment.d.ts.map

package/dist/types/ts4.1/global/globalRef.d.ts

@@ -0,0 +1,26 @@
+import type { AnyRecord } from '@amazon/vinyl-util';
+declare global {
+    /**
+     * A reference to Vinyl's global state, easily accessible via console.
+     */
+    var vinylGlobal: any;
+}
+/**
+ * For console debugging, gives access to currently active players, logs, and client information.
+ */
+export declare class VinylGlobal {
+    get players(): readonly AnyRecord[];
+    get player(): AnyRecord;
+    get logs(): (readonly import("@amazon/vinyl-util").HistoryLogItem[] | undefined);
+    get version(): string;
+    get userAgentInfo(): import("@amazon/vinyl-util").UserAgentInfo;
+    get network(): import("@amazon/vinyl-util").NetworkMetrics;
+    get bandwidth(): number;
+}
+/**
+ * Set the global vinylGlobal reference for easier console debugging.
+ * Intentionally typed as AnyRecord to prevent API usage from code. This is
+ * intended only for console debugging and the API may change at any time.
+ */
+export declare const vinylGlobalRef: import("@amazon/vinyl-util").GlobalRef<AnyRecord>;
+//# sourceMappingURL=globalRef.d.ts.map

package/dist/types/ts4.1/global/initializeVinylGlobal.d.ts

@@ -0,0 +1,2 @@
+export declare function initializeVinylGlobal(): void;
+//# sourceMappingURL=initializeVinylGlobal.d.ts.map

package/dist/types/ts4.1/index.d.ts

@@ -0,0 +1,132 @@
+/** Auto-generated from build scripts */
+export * from './vinyl/playerConfigFactory';
+export * from './vinyl/createVinylFactories';
+export * from './vinyl/VinylPlayer';
+export * from './vinyl/VinylPatchOptions';
+export * from './vinyl/VinylOptions';
+export * from './vinyl/VinylDeps';
+export * from './vinyl/ReadonlyPlaybackStreamingState';
+export * from './util/media/sourceBuffer';
+export * from './util/media/mediaSource';
+export * from './util/media/getAudioContext';
+export * from './track/createVinylTrackFactories';
+export * from './track/createSegmentDataProvider';
+export * from './track/TrackFactory';
+export * from './track/TrackController';
+export * from './track/TrackBase';
+export * from './track/Track';
+export * from './track/AutoResetController';
+export * from './track/source/SourceTrackBase';
+export * from './track/source/SourceTrack';
+export * from './track/source/SourceObjectTrack';
+export * from './track/source/FixedPlaybackQuality';
+export * from './track/mse/codec';
+export * from './track/mse/MseTrack';
+export * from './track/hls/createUrlHlsManifestProvider';
+export * from './track/hls/createHlsFactories';
+export * from './track/hls/createHlsContentTypesValue';
+export * from './track/hls/createHlsContentStreamFactories';
+export * from './track/hls/createDefaultHlsManifestTransformer';
+export * from './track/hls/buildHlsMediaTimeline';
+export * from './track/hls/HlsTrack';
+export * from './track/hls/HlsMediaQualityMetadataResolver';
+export * from './track/hls/HlsManifestProvider';
+export * from './track/hls/HlsManifestController';
+export * from './track/hls/util/hlsSegmentTime';
+export * from './track/hls/util/hlsByteRangeToMediaRange';
+export * from './track/filters/sampleRateFilter';
+export * from './track/filters/resourceTypeFilter';
+export * from './track/filters/languageFilter';
+export * from './track/filters/keySystemFilter';
+export * from './track/dash/urlDashManifestProvider';
+export * from './track/dash/manifestTransformUtils';
+export * from './track/dash/createSegmentControllerFactory';
+export * from './track/dash/createDefaultDashManifestTransformer';
+export * from './track/dash/createDashManifestProvider';
+export * from './track/dash/createDashFactories';
+export * from './track/dash/createDashContentTypesValue';
+export * from './track/dash/createDashContentStreamFactories';
+export * from './track/dash/buildDashMediaTimeline';
+export * from './track/dash/DashTrack';
+export * from './track/dash/DashMediaQualityMetadataResolver';
+export * from './track/dash/DashManifestProvider';
+export * from './track/dash/DashManifestController';
+export * from './track/dash/util/uriResolution';
+export * from './track/dash/util/mpd';
+export * from './track/dash/util/mimeType';
+export * from './track/dash/timeline/DashRepresentationSegmentProvider';
+export * from './streaming/mediaTimelineLanguageFilter';
+export * from './streaming/mediaTimelineFilter';
+export * from './streaming/createDefaultMediaTimelineTransformer';
+export * from './streaming/StreamingEventMap';
+export * from './streaming/SegmentReference';
+export * from './streaming/SegmentPrefetch';
+export * from './streaming/SegmentDataSlot';
+export * from './streaming/SegmentControllerImpl';
+export * from './streaming/SegmentController';
+export * from './streaming/MediaTimeline';
+export * from './streaming/MediaQualityMetadata';
+export * from './streaming/ManifestController';
+export * from './streaming/DrmInitDataType';
+export * from './streaming/DescriptorRecord';
+export * from './streaming/ContentTypesValue';
+export * from './streaming/ContentStreamingOptions';
+export * from './streaming/ContentStream';
+export * from './streaming/util/segment';
+export * from './streaming/buffering/SourceBufferController';
+export * from './streaming/buffering/MediaSourceController';
+export * from './streaming/buffering/BufferingController';
+export * from './streaming/buffering/error/SourceBufferError';
+export * from './streaming/abr/QualitySelectorImpl';
+export * from './streaming/abr/QualitySelector';
+export * from './playback/nextHasMetadata';
+export * from './playback/ReadonlyPlaybackController';
+export * from './playback/PlaybackSourceImpl';
+export * from './playback/PlaybackSource';
+export * from './playback/PlaybackControllerImpl';
+export * from './playback/PlaybackController';
+export * from './playback/loudness/LoudnessNormalizationControllerImplOptions';
+export * from './playback/loudness/LoudnessNormalizationControllerImpl';
+export * from './playback/loudness/LoudnessNormalizationController';
+export * from './playback/logging/playbackStateLoggingHandler';
+export * from './playback/logging/mediaErrorToJson';
+export * from './playback/error/ReportableMediaError';
+export * from './playback/error/InvalidSeekError';
+export * from './patch/media/patchMediaElement';
+export * from './patch/media/MediaElementPatchOptions';
+export * from './patch/media/HtmlMediaElementPatch';
+export * from './patch/media/patches/createUnreliablePlaybackEventsPatch';
+export * from './patch/media/patches/createPreventStallsPatch';
+export * from './global/initializeVinylGlobal';
+export * from './global/globalRef';
+export * from './global/environment';
+export * from './global/configureVinylGlobal';
+export * from './global/PlayerRegistry';
+export * from './event/ChangeEvent';
+export * from './event/BasicErrorEvent';
+export * from './drm/DrmOptions';
+export * from './drm/DrmKeySystemResolver';
+export * from './drm/DrmKeySystem';
+export * from './drm/DrmControllerImpl';
+export * from './drm/DrmController';
+export * from './drm/CencEncryptionScheme';
+export * from './drm/util/unpackPlayReadyChallenge';
+export * from './drm/util/extractContentId';
+export * from './drm/util/createFairPlaySessionInitData';
+export * from './drm/licenseProvider/defaultLicenseProvider';
+export * from './drm/licenseProvider/LicenseProvider';
+export * from './drm/error/DrmError';
+export * from './drm/dom/WebKitMediaKeys';
+export * from './drm/dom/MSMediaKeys';
+export * from './drm/dom/HTMLMediaElement';
+export * from './drm/commonEme/createDrmErrorHandler';
+export * from './drm/commonEme/WebKitCommonEme';
+export * from './drm/commonEme/StandardCommonEme';
+export * from './drm/commonEme/MsCommonEme';
+export * from './drm/commonEme/EncryptedInitData';
+export * from './drm/commonEme/CommonEmeFactory';
+export * from './drm/commonEme/CommonEme';
+export * from './client/Client';
+export * from './client/CapabilitiesImpl';
+export * from './client/Capabilities';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/ts4.1/patch/media/HtmlMediaElementPatch.d.ts

@@ -0,0 +1,3 @@
+import type { Patch } from '@amazon/vinyl-util';
+export type HtmlMediaElementPatch = Patch<HTMLMediaElement, HTMLMediaElementEventMap>;
+//# sourceMappingURL=HtmlMediaElementPatch.d.ts.map

package/dist/types/ts4.1/patch/media/MediaElementPatchOptions.d.ts

@@ -0,0 +1,19 @@
+export interface MediaElementPatchOptions {
+    /**
+     * Playback events 'playing' and 'waiting' are unreliable after seeking.
+     *
+     * Risks for false positive: LOW. Timing of emitted playing events may be subtly
+     * different, but they will not be duplicated.
+     * Risks for false negative: MEDIUM. Certain playback events on affected platforms will be missed.
+     */
+    readonly unreliablePlaybackEvents?: boolean;
+    /**
+     * The affected user agent gets into a state where playback can become stalled and needs help getting unstuck.
+     */
+    readonly preventStalls?: boolean;
+}
+/**
+ * Aggregates flags for toggling patches.
+ */
+export declare const defaultMediaElementPatchOptions: import("@amazon/vinyl-util").Lazy<Required<MediaElementPatchOptions>>;
+//# sourceMappingURL=MediaElementPatchOptions.d.ts.map

package/dist/types/ts4.1/patch/media/patchMediaElement.d.ts

@@ -0,0 +1,9 @@
+import type { PatchedRef } from '@amazon/vinyl-util';
+import type { MediaElementPatchOptions } from './MediaElementPatchOptions';
+/**
+ * Applies patches corresponding to the patch flags on the given media element.
+ *
+ * Adds logging for fabricated or squelched events.
+ */
+export declare function patchMediaElement<T extends HTMLMediaElement = HTMLMediaElement>(media: T, options: MediaElementPatchOptions): PatchedRef<T>;
+//# sourceMappingURL=patchMediaElement.d.ts.map

package/dist/types/ts4.1/patch/media/patches/createPreventStallsPatch.d.ts

@@ -0,0 +1,17 @@
+import type { HtmlMediaElementPatch } from '../../../patch/media/HtmlMediaElementPatch';
+/**
+ * The number of timeupdate events stuck at the same position before attempting to jiggle the playhead.
+ * @private
+ */
+export declare const MAX_UNCHANGED_COUNT = 10;
+/**
+ * On affected UAs, playback can become stuck. timeupdate events are observed but playback position is never changing.
+ * This patch applies a workaround which will pause and play again after max number of timeupdate events with no
+ * actual time progression.
+ */
+export declare function createPreventStallsPatch(media: HTMLMediaElement): HtmlMediaElementPatch;
+/**
+ * Returns true if stall detection should be enabled for the current user agent.
+ */
+export declare function requiresPreventStallsPatch(): boolean;
+//# sourceMappingURL=createPreventStallsPatch.d.ts.map

package/dist/types/ts4.1/patch/media/patches/createUnreliablePlaybackEventsPatch.d.ts

@@ -0,0 +1,26 @@
+import type { HtmlMediaElementPatch } from '../../../patch/media/HtmlMediaElementPatch';
+/**
+ * The interval (in seconds) to poll for time progress in a media element.
+ *
+ * @private
+ */
+export declare const UNRELIABLE_EVENTS_POLL_INTERVAL = 0.2;
+/**
+ * Minimum amount of time playback must be stalled before fabricating a waiting event.
+ */
+export declare const MIN_STALLED_BEFORE_FAB = 0.8;
+/**
+ * Minimum amount of time playback must be progressing before fabricating a playing event.
+ */
+export declare const MIN_PLAYING_BEFORE_FAB = 0.4;
+/**
+ * Playback events such as playing, canPlay, and waiting are unreliable on this platform.
+ * Watch playback state and fabricate events when necessary.
+ */
+export declare function createUnreliablePlaybackEventsPatch(media: HTMLMediaElement): HtmlMediaElementPatch;
+/**
+ * Chrome <= 53 has unreliable waiting events.
+ * Safari, and Edge Legacy miss playing events after seeking.
+ */
+export declare function requiresUnreliablePlaybackEventsPatch(): boolean;
+//# sourceMappingURL=createUnreliablePlaybackEventsPatch.d.ts.map

package/dist/types/ts4.1/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