@amazon/vinyl 1.0.0

package/dist/types/current/vinyl/VinylPlayer.js

@@ -0,0 +1,455 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { createDisposer, emptyRanges, equalDeep, EventHostImpl, logDebug, logInfo, redispatchEvents, } from '@amazon/vinyl-util';
+import { createContainer, } from '@amazon/vinyl-di';
+import { playerRegistryRef } from '../global/PlayerRegistry';
+import { ALL_PLAYBACK_STATE_EVENTS, } from '../playback/ReadonlyPlaybackController';
+import { ALL_TRACK_CONTROLLER_EVENTS, } from '../track/TrackController';
+import { createVinylFactories } from './createVinylFactories';
+import { initializeVinylGlobal } from '../global/initializeVinylGlobal';
+import { ALL_CONTENT_TYPES, } from '../streaming/MediaQualityMetadata';
+import { ALL_STREAMING_EVENTS, } from '../streaming/StreamingEventMap';
+/**
+ * A Vinyl Media Player.
+ *
+ * Unless custom dependencies need to be provided, use {@link createVinylPlayer} to construct
+ * a new player implementation.
+ */
+export class VinylPlayer extends EventHostImpl {
+    get [Symbol.toStringTag]() {
+        return 'VinylPlayer';
+    }
+    deps;
+    get drmController() {
+        return this.deps.drmController;
+    }
+    get playbackController() {
+        return this.deps.playbackController;
+    }
+    get trackController() {
+        return this.deps.trackController;
+    }
+    /**
+     * Provides information about the client, such as device and browser capabilities.
+     */
+    client;
+    _error = null;
+    disposer = createDisposer();
+    /**
+     * Constructs a new VinylPlayer with the given dependency factories.
+     * This constructor is protected, use {@link createVinylPlayer} to construct a new player.
+     *
+     * @param factories
+     * @see createVinylPlayer
+     */
+    constructor(factories) {
+        initializeVinylGlobal();
+        super();
+        const add = this.disposer.add;
+        this.deps = add(createContainer(factories)).dependencies;
+        this.client = {
+            capabilities: this.deps.capabilities,
+        };
+        playerRegistryRef.value.addPlayer(this);
+        this.redispatchSubControllerEvents();
+        this.redispatchCurrentTrackEvents();
+        this.initializeAutoResetHandling();
+        this.initializePreferredLanguageHandling();
+    }
+    redispatchSubControllerEvents() {
+        const add = this.disposer.add;
+        add(redispatchEvents(this, this.playbackController, ALL_PLAYBACK_STATE_EVENTS.filter(notResetEvent)));
+        add(redispatchEvents(this, this.trackController, ALL_TRACK_CONTROLLER_EVENTS));
+        add(redispatchEvents(this, this.drmController, ['error']));
+        this.on('error', (event) => {
+            this._error = event.error;
+        });
+    }
+    /**
+     * Certain track events are redispatched on the player for the current track.
+     */
+    redispatchCurrentTrackEvents() {
+        let sub = null;
+        const add = this.disposer.add;
+        add(this.trackController.on('currentTrackChange', (event) => {
+            sub?.();
+            sub = null;
+            if (event.current) {
+                sub = redispatchEvents(this, event.current, ALL_STREAMING_EVENTS.filter(notResetEvent));
+            }
+            this.dispatch('fetchedRangesChange', {});
+            // Emit a quality change event for every stream that has changed
+            // for streaming, buffering, and playback
+            for (const contentType of ALL_CONTENT_TYPES) {
+                for (const [eventType, getterName,] of qualityEventsAndGetters) {
+                    const previous = event.previous?.[getterName](contentType) ?? null;
+                    const current = event.current?.[getterName](contentType) ?? null;
+                    if (previous !== current) {
+                        this.dispatch(eventType, {
+                            previous,
+                            current,
+                        });
+                    }
+                }
+            }
+            // Emit qualities change events on track switch
+            const prevQualities = event.previous?.qualities ?? null;
+            const curQualities = event.current?.qualities ?? null;
+            if (prevQualities !== curQualities && curQualities) {
+                this.dispatch('qualitiesChange', {
+                    previous: prevQualities ?? [],
+                    current: curQualities,
+                });
+            }
+            const prevUnfiltered = event.previous?.qualitiesUnfiltered ?? null;
+            const curUnfiltered = event.current?.qualitiesUnfiltered ?? null;
+            if (prevUnfiltered !== curUnfiltered && curUnfiltered) {
+                this.dispatch('qualitiesUnfilteredChange', {
+                    previous: prevUnfiltered ?? [],
+                    current: curUnfiltered,
+                });
+            }
+        }));
+    }
+    initializeAutoResetHandling() {
+        // Initializes the binding between the player and the reset handler.
+        // On an error, notify the auto reset controller which will
+        // monitor network changes and periodically request a reset.
+        const { add } = this.disposer;
+        const { autoResetController } = this.deps;
+        this.on('error', (event) => {
+            autoResetController.setError(event.error);
+        });
+        add(autoResetController.on('reset', () => this.reset()));
+    }
+    initializePreferredLanguageHandling() {
+        const { add } = this.disposer;
+        // When the preferred language changes, clear the prefetch to immediately switch.
+        add(this.deps.options
+            .pick('preferredAudioLanguage')
+            .onData((_value, previous) => {
+            if (previous !== undefined)
+                this.clearPrefetch();
+        }));
+    }
+    /**
+     * Returns the current player options.
+     * Use `configure` to set.
+     */
+    get options() {
+        return this.deps.options.value;
+    }
+    /**
+     * Sets options on this player.
+     * Options will be merged shallowly, for example,
+     * `configure({ abr: { strategy: AbrStrategy.BEST }})` will replace all previous `abr` options, and not
+     * change other options such as `loudnessNormalization`.
+     *
+     * @param options
+     */
+    configure(options) {
+        logDebug(this, 'configure', options);
+        const newValue = { ...this.options, ...options };
+        if (!equalDeep(newValue, this.options)) {
+            this.deps.options.value = newValue;
+        }
+    }
+    get capabilities() {
+        return this.deps.capabilities;
+    }
+    //----------------------------------------------------
+    // PlaybackController delegate methods
+    //----------------------------------------------------
+    get buffered() {
+        return this.playbackController.buffered;
+    }
+    get canPlay() {
+        return this.playbackController.canPlay;
+    }
+    get canPlayThrough() {
+        return this.playbackController.canPlayThrough;
+    }
+    get currentTime() {
+        return this.playbackController.currentTime;
+    }
+    get currentTimePercent() {
+        return this.playbackController.currentTimePercent;
+    }
+    get defaultPlaybackRate() {
+        return this.playbackController.defaultPlaybackRate;
+    }
+    set defaultPlaybackRate(value) {
+        this.playbackController.defaultPlaybackRate = value;
+    }
+    get duration() {
+        return this.playbackController.duration;
+    }
+    get ended() {
+        return this.playbackController.ended;
+    }
+    /**
+     * The last error reported.
+     */
+    get error() {
+        return this._error;
+    }
+    get hasMetadata() {
+        return this.playbackController.hasMetadata;
+    }
+    get loop() {
+        return this.playbackController.loop;
+    }
+    set loop(value) {
+        this.playbackController.loop = value;
+    }
+    get muted() {
+        return this.playbackController.muted;
+    }
+    set muted(value) {
+        this.playbackController.muted = value;
+    }
+    get networkState() {
+        return this.playbackController.networkState;
+    }
+    get paused() {
+        return this.playbackController.paused;
+    }
+    get playbackRate() {
+        return this.playbackController.playbackRate;
+    }
+    set playbackRate(value) {
+        this.playbackController.playbackRate = value;
+    }
+    get playIsPending() {
+        return this.playbackController.playIsPending;
+    }
+    get playing() {
+        return this.playbackController.playing;
+    }
+    get preservesPitch() {
+        return this.playbackController.preservesPitch;
+    }
+    set preservesPitch(value) {
+        this.playbackController.preservesPitch = value;
+    }
+    get readyState() {
+        return this.playbackController.readyState;
+    }
+    get seekable() {
+        return this.playbackController.seekable;
+    }
+    get seeking() {
+        return this.playbackController.seeking;
+    }
+    get volume() {
+        return this.playbackController.volume;
+    }
+    set volume(value) {
+        this.playbackController.volume = value;
+    }
+    get waiting() {
+        return this.playbackController.waiting;
+    }
+    pause() {
+        this.playbackController.pause();
+    }
+    play() {
+        return this.playbackController.play();
+    }
+    seekTo(time, tolerance) {
+        return this.playbackController.seekTo(time, tolerance);
+    }
+    reset() {
+        if (!this._error) {
+            logDebug(this, 'reset no-op');
+            return;
+        }
+        logDebug(this, 'reset');
+        this._error = null;
+        this.drmController.reset();
+        this.playbackController.reset();
+        this.trackController.reset();
+        this.dispatch('reset', {});
+    }
+    //----------------------------------------------------
+    // TrackController delegate methods
+    //----------------------------------------------------
+    get currentTrack() {
+        return this.trackController.currentTrack;
+    }
+    get queue() {
+        return this.trackController.queue;
+    }
+    preload(...loadOptionsList) {
+        this.trackController.preload(...loadOptionsList);
+    }
+    load(...loadOptionsList) {
+        this.trackController.load(...loadOptionsList);
+    }
+    enqueue(...loadOptionsList) {
+        this.trackController.enqueue(...loadOptionsList);
+    }
+    unload() {
+        this.trackController.unload();
+    }
+    hasNext() {
+        return this.trackController.hasNext();
+    }
+    next() {
+        return this.trackController.next();
+    }
+    isTrackCached(uri) {
+        return this.trackController.isTrackCached(uri);
+    }
+    getCachedTrack(uri) {
+        return this.trackController.getCachedTrack(uri);
+    }
+    getCachedTracks() {
+        return this.trackController.getCachedTracks();
+    }
+    clearPrefetch() {
+        this.trackController.clearPrefetch();
+    }
+    clearTrackCache() {
+        this.trackController.clearTrackCache();
+    }
+    clearQueue() {
+        this.trackController.clearQueue();
+    }
+    //----------------------------------------------------
+    // CurrentTrackStreamingState methods
+    //----------------------------------------------------
+    /**
+     * Returns the fetched ranges of the current track.
+     * If there is no current track, empty ranges will be returned.
+     *
+     * Listen to {@link VinylPlayerEventMap.fetchedRangesChange} for changes.
+     */
+    get fetchedRanges() {
+        return this.currentTrack?.fetchedRanges ?? emptyRanges;
+    }
+    /**
+     * Returns the time of the prefetch end.
+     * If no data has been prefetched for the current track, 0 will be returned.
+     *
+     * The time given will be in seconds according to the media timeline.
+     * It will represent the ending time of the continuous prefetch range from the current playhead time.
+     */
+    get fetchedTime() {
+        const time = this.playbackController.currentTime;
+        const range = this.fetchedRanges.getRangeAt(time);
+        if (!range)
+            return 0;
+        return range[1];
+    }
+    /**
+     * Returns current fetched time as a percent of the total duration.
+     *
+     * @return A number between 0-1
+     */
+    get fetchedTimePercent() {
+        return this.duration > 0 ? this.fetchedTime / this.duration : 0;
+    }
+    /**
+     * Returns the current content types for active streams.
+     */
+    get contentTypes() {
+        return this.currentTrack?.contentTypes ?? emptyContentTypes;
+    }
+    /**
+     * The available qualities for the current period of the current track, after filtering.
+     * Null if no track is active or the timeline is not yet available.
+     */
+    get qualities() {
+        return this.currentTrack?.qualities ?? null;
+    }
+    /**
+     * The available unfiltered qualities for the current period of the current track.
+     * Null if no track is active or the timeline is not yet available.
+     */
+    get qualitiesUnfiltered() {
+        return this.currentTrack?.qualitiesUnfiltered ?? null;
+    }
+    /**
+     * @deprecated Use `getStreamingQuality('audio')`
+     */
+    get streamingQuality() {
+        return this.getStreamingQuality('audio');
+    }
+    /**
+     * @deprecated Use `getBufferingQuality('audio')
+     */
+    get bufferingQuality() {
+        return this.getStreamingQuality('audio');
+    }
+    /**
+     * @deprecated Use `getPlaybackQuality('audio')
+     */
+    get playbackQuality() {
+        return this.getPlaybackQuality('audio');
+    }
+    /**
+     * The streaming quality for the current track.
+     * Note that this does not represent the quality of inactive preloading tracks.
+     */
+    getStreamingQuality(contentType) {
+        return this.currentTrack?.getStreamingQuality(contentType) ?? null;
+    }
+    /**
+     * The currently buffering quality, or null if no data is buffered.
+     */
+    getBufferingQuality(contentType) {
+        return this.currentTrack?.getBufferingQuality(contentType) ?? null;
+    }
+    /**
+     * The currently playing quality, or null if no media is playing.
+     */
+    getPlaybackQuality(contentType) {
+        return this.currentTrack?.getPlaybackQuality(contentType) ?? null;
+    }
+    //----------------------------------------------------
+    /**
+     * Returns true if this player has been disposed.
+     */
+    get disposed() {
+        return this.disposer.disposed;
+    }
+    /**
+     * Disposes this player and sub-systems.
+     */
+    dispose() {
+        logDebug(this, 'dispose');
+        super.dispose();
+        this.disposer.dispose();
+        playerRegistryRef.value.removePlayer(this);
+    }
+}
+/**
+ * Constructs a new {@link VinylPlayer}.
+ *
+ * @param options Configuration for default dependencies.
+ * @param factoryOverrides Dependency factory overrides.
+ */
+export function createVinylPlayer(options, factoryOverrides) {
+    const player = new VinylPlayer({
+        ...createVinylFactories(options),
+        ...factoryOverrides,
+    });
+    logInfo(player, `VinylPlayer initialized`);
+    return player;
+}
+/**
+ * Do not redispatch reset events, only emit the reset event when `player.reset` is called.
+ * @param type
+ */
+function notResetEvent(type) {
+    return type !== 'reset';
+}
+const qualityEventsAndGetters = [
+    ['streamingQualityChange', 'getStreamingQuality'],
+    ['bufferingQualityChange', 'getBufferingQuality'],
+    ['playbackQualityChange', 'getPlaybackQuality'],
+];
+const emptyContentTypes = new Set();

package/dist/types/current/vinyl/createVinylFactories.d.ts

@@ -0,0 +1,177 @@
+import type { CapabilitiesImplDeps } from '../client/CapabilitiesImpl';
+import { CapabilitiesImpl } from '../client/CapabilitiesImpl';
+import type { Merge, PartialDeep, PatchedRef } from '@amazon/vinyl-util';
+import { noop } from '@amazon/vinyl-util';
+import type { PlaybackControllerImplDeps, PlaybackControllerImplOptions } from '../playback/PlaybackControllerImpl';
+import { PlaybackControllerImpl } from '../playback/PlaybackControllerImpl';
+import type { PlaybackSourceImplDeps } from '../playback/PlaybackSourceImpl';
+import { PlaybackSourceImpl } from '../playback/PlaybackSourceImpl';
+import { type VinylTrackFactoryDeps } from '../track/createVinylTrackFactories';
+import type { TrackControllerImplDeps, TrackControllerImplOptions } from '../track/TrackController';
+import { TrackControllerImpl } from '../track/TrackController';
+import type { VinylPatchOptions } from './VinylPatchOptions';
+import { type QualitySelectorImplOptions } from '../streaming/abr/QualitySelectorImpl';
+import { type DrmOptions } from '../drm/DrmOptions';
+import { commonEmeFactory } from '../drm/commonEme/CommonEmeFactory';
+import { DrmControllerImpl, type DrmControllerImplDeps } from '../drm/DrmControllerImpl';
+import { LoudnessNormalizationControllerImpl } from '../playback/loudness/LoudnessNormalizationControllerImpl';
+import { AutoResetControllerImpl, type AutoResetControllerImplDeps, type AutoResetControllerImplOptions } from '../track/AutoResetController';
+import type { Dependencies, Factories } from '@amazon/vinyl-di';
+import type { ContentStreamingOptions } from '../streaming/ContentStreamingOptions';
+import { type VinylOptions } from '../vinyl/VinylOptions';
+import type { ObservableValue } from '@amazon/vinyl-observable';
+/**
+ * Configuration used by the default dependency factories for Vinyl.
+ *
+ * These options are used during player construction, changes after construction will have no
+ * effect.
+ */
+export interface VinylDependencyOptions {
+    /**
+     * The media element.
+     */
+    readonly media: HTMLMediaElement;
+    /**
+     * Flags for patches that should be applied browser-specifically.
+     * These will be defaulted based on the user-agent.
+     */
+    readonly patches?: PartialDeep<VinylPatchOptions>;
+    /**
+     * Configuration for the track controller.
+     */
+    readonly trackController?: Partial<TrackControllerImplOptions>;
+    /**
+     * Configuration for the playback controller.
+     */
+    readonly playbackController?: Partial<PlaybackControllerImplOptions>;
+    /**
+     * Configuration for segmented streaming tracks (hls / dash).
+     */
+    readonly streaming?: PartialDeep<ContentStreamingOptions>;
+    /**
+     * Configuration for all drm-related components.
+     */
+    readonly drm?: Partial<DrmOptions>;
+    /**
+     * Configuration for adaptive bitrate switching.
+     */
+    readonly abr?: PartialDeep<QualitySelectorImplOptions>;
+    /**
+     * Configuration for auto-reset behavior.
+     */
+    readonly autoReset?: Partial<AutoResetControllerImplOptions>;
+}
+/**
+ * Creates the dependency factories for a standard player.
+ *
+ * @param options
+ */
+export declare function createVinylFactories(options: VinylDependencyOptions): NoInfer<{
+    options: (_deps: import("@amazon/vinyl-util").AnyRecord, add: import("@amazon/vinyl-util").AddDisposable) => import("@amazon/vinyl-observable").MutableValue<VinylOptions>;
+    patchedMedia: () => PatchedRef<HTMLMediaElement>;
+    media: (deps: {
+        readonly patchedMedia: {
+            readonly patched: HTMLMediaElement;
+        };
+    }) => HTMLMediaElement;
+    playbackController: (deps: PlaybackControllerImplDeps) => PlaybackControllerImpl;
+    playbackSource: (deps: PlaybackSourceImplDeps) => PlaybackSourceImpl;
+    loudnessNormalizationController: (deps: {
+        options: ObservableValue<Pick<VinylOptions, "loudnessNormalization">>;
+    }) => LoudnessNormalizationControllerImpl;
+    capabilities: (deps: CapabilitiesImplDeps) => CapabilitiesImpl;
+    requestInterceptor: () => typeof noop;
+    trackFactory: (deps: VinylTrackFactoryDeps) => import("../track/TrackFactory").TrackFactory<import("..").SourceObjectTrackLoadOptions | import("..").SourceTrackLoadOptions | import("..").DashTrackLoadOptions | import("..").HlsTrackLoadOptions>;
+    trackController: (deps: TrackControllerImplDeps<any>) => TrackControllerImpl<any>;
+    drmKeySystemResolver: () => import("../drm/DrmKeySystemResolver").DrmKeySystemResolver;
+    drmController: (deps: DrmControllerImplDeps) => DrmControllerImpl;
+    commonEme: typeof commonEmeFactory;
+    autoResetController: (deps: AutoResetControllerImplDeps) => AutoResetControllerImpl;
+    createDashFactories: (deps: import("../track/dash/createDashFactories").DashFactoryDeps) => (/**
+     * Configuration for segmented streaming tracks (hls / dash).
+     */ loadOptions: import("..").DashTrackLoadOptions) => NoInfer<{
+        contentTypesValue: typeof import("..").createDashContentTypesValue;
+        baseUrlSelector: () => import("..").BaseUrlSelector;
+        segmentRequestInit: () => import("@amazon/vinyl-util").Maybe<Readonly<Omit<RequestInit, "signal">>>;
+        manifestProvider: (deps: {
+            readonly requestInterceptor: import("@amazon/vinyl-util").RequestInterceptor;
+        }) => import("..").DashManifestProvider;
+        manifestController: (deps: import("..").DashManifestControllerImplDeps) => import("..").DashManifestController;
+        mediaSourceFactory: () => typeof import("..").createMediaSource;
+        mediaQualityMetadataResolver: (deps: import("..").DashMediaQualityMetadataResolverDeps) => import("..").DashMediaQualityMetadataResolver;
+        mediaSourceController: (deps: import("..").MediaSourceControllerImplDeps) => import("..").MediaSourceControllerImpl;
+        createContentStreamFactories: (deps: import("..").DashContentStreamTrackDeps) => import("@amazon/vinyl-util").MemoizedFunction & ((contentType: import("..").ContentType) => NoInfer<{
+            sourceBufferControllerFactory: (deps: import("..").SourceBufferControllerImplDeps) => () => import("..").SourceBufferControllerImpl;
+            bufferingController: (deps: import("..").BufferingControllerImplDeps) => import("..").BufferingControllerImpl;
+            segmentController: (deps: import("..").SegmentControllerImplDeps) => import("..").SegmentControllerImpl;
+            mediaSourceController: import("@amazon/vinyl-di").Factory<import("..").MediaSourceController>;
+            playbackController: import("@amazon/vinyl-di").Factory<import("..").PlaybackController>;
+            mediaTimelineTransformed: import("@amazon/vinyl-di").Factory<ObservableValue<Promise<import("..").MediaTimeline>>>;
+            qualitySelector: import("@amazon/vinyl-di").Factory<import("..").QualitySelector>;
+        }>);
+        contentStreamFactory: typeof import("..").createContentStreamFactory;
+        qualitySelector: (deps: {
+            options: ObservableValue<Pick<VinylOptions, "abr">>;
+        }) => import("../streaming/abr/QualitySelectorImpl").QualitySelectorImpl;
+        manifestTransformed: typeof import("..").createDefaultDashManifestTransformer;
+        mediaTimeline: (deps: import("..").BuildDashMediaTimelineDeps & {
+            readonly manifestTransformed: ObservableValue<Promise<import("..").DashManifestData>>;
+        }) => ObservableValue<Promise<import("..").MediaTimeline>>;
+        mediaTimelineTransformed: typeof import("..").createDefaultMediaTimelineTransformer;
+        options: import("@amazon/vinyl-di").Factory<ObservableValue<{
+            readonly abr: QualitySelectorImplOptions;
+            readonly preferredAudioLanguage: string | null;
+        }>>;
+        playbackController: import("@amazon/vinyl-di").Factory<import("..").PlaybackController>;
+        playbackSource: import("@amazon/vinyl-di").Factory<import("..").PlaybackSource>;
+        drmKeySystemResolver: import("@amazon/vinyl-di").Factory<import("../drm/DrmKeySystemResolver").DrmKeySystemResolver>;
+        requestInterceptor: import("@amazon/vinyl-di").Factory<import("@amazon/vinyl-util").RequestInterceptor>;
+        drmController: import("@amazon/vinyl-di").Factory<import("..").DrmController>;
+        capabilities: import("@amazon/vinyl-di").Factory<import("..").Capabilities>;
+    }>;
+    createHlsFactories: (deps: import("../track/hls/createHlsFactories").HlsFactoryDeps) => (loadOptions: import("..").HlsTrackLoadOptions) => NoInfer<{
+        contentTypesValue: typeof import("..").createHlsContentTypesValue;
+        manifestController: () => import("..").HlsManifestControllerImpl;
+        manifestTransformed: typeof import("..").createDefaultHlsManifestTransformer;
+        mediaQualityMetadataResolver: () => import("..").HlsMediaQualityMetadataResolver;
+        mediaSourceFactory: () => typeof import("..").createMediaSource;
+        mediaSourceController: (deps: import("..").MediaSourceControllerImplDeps) => import("..").MediaSourceControllerImpl;
+        segmentRequestInit: () => import("@amazon/vinyl-util").Maybe<Readonly<Omit<RequestInit, "signal">>>;
+        createContentStreamFactories: (deps: import("..").HlsContentStreamTrackDeps) => import("@amazon/vinyl-util").MemoizedFunction & ((contentType: import("..").ContentType) => NoInfer<{
+            sourceBufferControllerFactory: (deps: import("..").SourceBufferControllerImplDeps) => () => import("..").SourceBufferControllerImpl;
+            bufferingController: (deps: import("..").BufferingControllerImplDeps) => import("..").BufferingControllerImpl;
+            segmentController: (deps: import("..").SegmentControllerImplDeps) => import("..").SegmentControllerImpl;
+            mediaSourceController: import("@amazon/vinyl-di").Factory<import("..").MediaSourceController>;
+            playbackController: import("@amazon/vinyl-di").Factory<import("..").PlaybackController>;
+            mediaTimelineTransformed: import("@amazon/vinyl-di").Factory<ObservableValue<Promise<import("..").MediaTimeline>>>;
+            qualitySelector: import("@amazon/vinyl-di").Factory<import("..").QualitySelector>;
+        }>);
+        contentStreamFactory: typeof import("..").createContentStreamFactory;
+        qualitySelector: (deps: {
+            options: ObservableValue<Pick<VinylOptions, "abr">>;
+        }) => import("../streaming/abr/QualitySelectorImpl").QualitySelectorImpl;
+        mediaTimeline: (deps: import("..").BuildHlsMediaTimelineDeps & {
+            readonly manifestTransformed: ObservableValue<Promise<import("..").HlsManifestData>>;
+        }) => ObservableValue<Promise<import("..").MediaTimeline>>;
+        mediaTimelineTransformed: typeof import("..").createDefaultMediaTimelineTransformer;
+        options: import("@amazon/vinyl-di").Factory<ObservableValue<{
+            readonly abr: QualitySelectorImplOptions;
+            readonly preferredAudioLanguage: string | null;
+        }>>;
+        playbackController: import("@amazon/vinyl-di").Factory<import("..").PlaybackController>;
+        playbackSource: import("@amazon/vinyl-di").Factory<import("..").PlaybackSource>;
+        drmKeySystemResolver: import("@amazon/vinyl-di").Factory<import("../drm/DrmKeySystemResolver").DrmKeySystemResolver>;
+        requestInterceptor: import("@amazon/vinyl-di").Factory<import("@amazon/vinyl-util").RequestInterceptor>;
+        drmController: import("@amazon/vinyl-di").Factory<import("..").DrmController>;
+        capabilities: import("@amazon/vinyl-di").Factory<import("..").Capabilities>;
+    }>;
+}>;
+/**
+ * The dependency map type of the default player dependency factories.
+ */
+export type DefaultVinylFactories = ReturnType<typeof createVinylFactories>;
+/**
+ * Provides the dependency type for a dependency with merged overrides.
+ */
+export type InferVinylOverrideDependencyType<Overrides, K extends keyof DefaultVinylFactories> = Dependencies<Overrides extends Factories ? Merge<DefaultVinylFactories, Overrides> : DefaultVinylFactories>[K];
+//# sourceMappingURL=createVinylFactories.d.ts.map

package/dist/types/current/vinyl/createVinylFactories.d.ts.map

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