@amazon/vinyl 1.1.1 → 1.2.1

package/dist/types/ts3.7/track/TrackController.d.ts

@@ -1,7 +1,7 @@
 import { AnyRecord, Disposable, EventHostImpl, Maybe, ReadonlyEventHost } from '@amazon/vinyl-util';
 import { PlaybackController } from '../playback/PlaybackController';
-import { ReadonlyTrack, TrackUri } from '../track/Track';
-import { TrackFactory, TrackLoadOptions } from '../track/TrackFactory';
+import { ReadonlyTrack, TrackUri } from './Track';
+import { TrackFactory, TrackLoadOptions } from './TrackFactory';
 import { ChangeEvent } from '../event/ChangeEvent';
 export interface TrackControllerEventMap<TrackLoadOptionsType extends TrackLoadOptions> {
     /**

package/dist/types/ts3.7/track/TrackFactory.d.ts

@@ -1,6 +1,6 @@
 import { AnyRecord, Maybe, ReadonlyRecord } from '@amazon/vinyl-util';
 import { ObjectSchema } from '@amazon/vinyl-validation';
-import { Track, TrackTypeId, TrackUri } from '../track/Track';
+import { Track, TrackTypeId, TrackUri } from './Track';
 export interface TrackLoadOptions {
     /**
      * The track type, used to map to a track factory.

package/dist/types/ts3.7/track/createVinylTrackFactories.d.ts

@@ -1,8 +1,8 @@
-import { SourceObjectTrackDeps, SourceObjectTrackLoadOptions } from '../track/source/SourceObjectTrack';
-import { SourceTrackDeps, SourceTrackLoadOptions } from '../track/source/SourceTrack';
-import { TrackFactory } from '../track/TrackFactory';
-import { DashTrackFactoryDeps, DashTrackLoadOptions } from '../track/dash/DashTrack';
-import { HlsTrackFactoryDeps, HlsTrackLoadOptions } from '../track/hls/HlsTrack';
+import { SourceObjectTrackDeps, SourceObjectTrackLoadOptions } from './source/SourceObjectTrack';
+import { SourceTrackDeps, SourceTrackLoadOptions } from './source/SourceTrack';
+import { TrackFactory } from './TrackFactory';
+import { DashTrackFactoryDeps, DashTrackLoadOptions } from './dash/DashTrack';
+import { HlsTrackFactoryDeps, HlsTrackLoadOptions } from './hls/HlsTrack';
 export interface VinylTrackFactoryDeps extends SourceTrackDeps, SourceObjectTrackDeps, DashTrackFactoryDeps, HlsTrackFactoryDeps {
 }
 export type VinylTrackLoadOptions = SourceObjectTrackLoadOptions | SourceTrackLoadOptions | DashTrackLoadOptions | HlsTrackLoadOptions;

package/dist/types/ts3.7/track/dash/DashManifestController.d.ts

@@ -1,4 +1,4 @@
-import { DashManifestData, DashManifestProvider } from '../../track/dash/DashManifestProvider';
+import { DashManifestData, DashManifestProvider } from './DashManifestProvider';
 import { ManifestController } from '../../streaming/ManifestController';
 export type DashManifestController = ManifestController<Promise<DashManifestData>>;
 export interface DashManifestControllerImplDeps {

package/dist/types/ts3.7/track/dash/DashTrack.d.ts

@@ -1,12 +1,12 @@
-import { TrackBaseOptions } from '../../track/TrackBase';
+import { TrackBaseOptions } from '../TrackBase';
 import { DashManifestProvider, DashManifestData } from './DashManifestProvider';
 import { DashManifestController } from './DashManifestController';
-import { TrackFactory, TrackLoadOptions } from '../../track/TrackFactory';
+import { TrackFactory, TrackLoadOptions } from '../TrackFactory';
 import { ObservableValue } from '@amazon/vinyl-observable';
 import { Maybe, RequestInitOptions } from '@amazon/vinyl-util';
 import { Factories } from '@amazon/vinyl-di';
-import { DashMediaQualityMetadataResolver } from '../../track/dash/DashMediaQualityMetadataResolver';
-import { MseTrackDeps } from '../../track/mse/MseTrack';
+import { DashMediaQualityMetadataResolver } from './DashMediaQualityMetadataResolver';
+import { MseTrackDeps } from '../mse/MseTrack';
 import { MediaTimeline } from '../../streaming/MediaTimeline';
 export interface DashTrackLoadOptions extends TrackLoadOptions {
     readonly type: 'dash';

package/dist/types/ts3.7/track/dash/buildDashMediaTimeline.d.ts

@@ -1,6 +1,6 @@
-import { DashManifestData } from '../../track/dash/DashManifestProvider';
+import { DashManifestData } from './DashManifestProvider';
 import { MediaTimeline } from '../../streaming/MediaTimeline';
-import { DashSegmentProviderDeps } from '../../track/dash/timeline/DashRepresentationSegmentProvider';
+import { DashSegmentProviderDeps } from './timeline/DashRepresentationSegmentProvider';
 export type BuildDashMediaTimelineDeps = DashSegmentProviderDeps;
 /**
  * Builds a MediaTimeline from a Dash manifest.

package/dist/types/ts3.7/track/dash/createDashContentTypesValue.d.ts

@@ -1,5 +1,5 @@
-import { DashManifestData } from '../../track/dash/DashManifestProvider';
-import { DashMediaQualityMetadataResolver } from '../../track/dash/DashMediaQualityMetadataResolver';
+import { DashManifestData } from './DashManifestProvider';
+import { DashMediaQualityMetadataResolver } from './DashMediaQualityMetadataResolver';
 import { ContentTypesValue } from '../../streaming/ContentTypesValue';
 import { ObservableValue } from '@amazon/vinyl-observable';
 export interface DashContentTypesValueDeps {

package/dist/types/ts3.7/track/dash/createDashFactories.d.ts

@@ -1,11 +1,11 @@
-import { DashTrackLoadOptions } from '../../track/dash/DashTrack';
+import { DashTrackLoadOptions } from './DashTrack';
 import { Maybe, RequestInterceptor } from '@amazon/vinyl-util';
-import { createDefaultDashManifestTransformer } from '../../track/dash/createDefaultDashManifestTransformer';
+import { createDefaultDashManifestTransformer } from './createDefaultDashManifestTransformer';
 import { createMediaSource } from '../../util/media/mediaSource';
-import { DashMediaQualityMetadataResolverDeps } from '../../track/dash/DashMediaQualityMetadataResolver';
+import { DashMediaQualityMetadataResolverDeps } from './DashMediaQualityMetadataResolver';
 import { MediaSourceControllerImpl, MediaSourceControllerImplDeps } from '../../streaming/buffering/MediaSourceController';
 import { PlaybackController } from '../../playback/PlaybackController';
-import { DashManifestController, DashManifestControllerImplDeps } from '../../track/dash/DashManifestController';
+import { DashManifestController, DashManifestControllerImplDeps } from './DashManifestController';
 import { DrmKeySystemResolver } from '../../drm/DrmKeySystemResolver';
 import { DrmController } from '../../drm/DrmController';
 import { Capabilities } from '../../client/Capabilities';
@@ -13,12 +13,12 @@ import { QualitySelectorImpl, QualitySelectorImplOptions } from '../../streaming
 import { PlaybackSource } from '../../playback/PlaybackSource';
 import { createContentStreamFactory } from '../../streaming/ContentStream';
 import { ContentStreamingOptions } from '../../streaming/ContentStreamingOptions';
-import { createDashContentTypesValue } from '../../track/dash/createDashContentTypesValue';
+import { createDashContentTypesValue } from './createDashContentTypesValue';
 import { ObservableValue } from '@amazon/vinyl-observable';
 import { VinylOptions } from '../../vinyl/VinylOptions';
-import { BuildDashMediaTimelineDeps } from '../../track/dash/buildDashMediaTimeline';
+import { BuildDashMediaTimelineDeps } from './buildDashMediaTimeline';
 import { createDefaultMediaTimelineTransformer } from '../../streaming/createDefaultMediaTimelineTransformer';
-import { DashManifestData } from '../../track/dash/DashManifestProvider';
+import { DashManifestData } from './DashManifestProvider';
 /**
  * Player-level dependencies needed for the Dash-specific factories.
  */
@@ -43,20 +43,20 @@ export type DashInitOptions = {
  */
 export declare function createDashFactories(options: Maybe<DashInitOptions>): (deps: DashFactoryDeps) => (loadOptions: DashTrackLoadOptions) => {
     contentTypesValue: typeof createDashContentTypesValue;
-    baseUrlSelector: () => import("../../track/dash/util/uriResolution").BaseUrlSelector;
+    baseUrlSelector: () => import("./util/uriResolution").BaseUrlSelector;
     segmentRequestInit: () => Maybe<Readonly<Omit<RequestInit, "signal">>>;
     manifestProvider: (deps: {
         readonly requestInterceptor: RequestInterceptor;
-    }) => import("../../track/dash/DashManifestProvider").DashManifestProvider;
+    }) => import("./DashManifestProvider").DashManifestProvider;
     manifestController: (deps: DashManifestControllerImplDeps) => DashManifestController;
     mediaSourceFactory: () => typeof createMediaSource;
-    mediaQualityMetadataResolver: (deps: DashMediaQualityMetadataResolverDeps) => import("../../track/dash/DashMediaQualityMetadataResolver").DashMediaQualityMetadataResolver;
+    mediaQualityMetadataResolver: (deps: DashMediaQualityMetadataResolverDeps) => import("./DashMediaQualityMetadataResolver").DashMediaQualityMetadataResolver;
     mediaSourceController: (deps: MediaSourceControllerImplDeps) => MediaSourceControllerImpl;
-    createContentStreamFactories: (deps: import("../../track/dash/createDashContentStreamFactories").DashContentStreamTrackDeps) => import("@amazon/vinyl-util").MemoizedFunction & ((contentType: import("../..").ContentType) => {
+    createContentStreamFactories: (deps: import("./createDashContentStreamFactories").DashContentStreamTrackDeps) => import("@amazon/vinyl-util").MemoizedFunction & ((contentType: import("../..").ContentType) => {
         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("../../streaming/buffering/MediaSourceController").MediaSourceController>;
+        mediaSourceController: import("@amazon/vinyl-di").Factory<import("../..").MediaSourceController>;
         playbackController: import("@amazon/vinyl-di").Factory<PlaybackController>;
         mediaTimelineTransformed: import("@amazon/vinyl-di").Factory<ObservableValue<Promise<import("../..").MediaTimeline>>>;
         qualitySelector: import("@amazon/vinyl-di").Factory<import("../..").QualitySelector>;

package/dist/types/ts3.7/track/dash/createDashManifestProvider.d.ts

@@ -1,4 +1,4 @@
-import { DashTrackLoadOptions } from '../../track/dash/DashTrack';
+import { DashTrackLoadOptions } from './DashTrack';
 import { RequestInterceptor } from '@amazon/vinyl-util';
 /**
  * Creates a DashManifestProvider which uses the manifestProvider set on the loadOptions, or a urlDashManifestProvider

package/dist/types/ts3.7/track/dash/createDefaultDashManifestTransformer.d.ts

@@ -1,5 +1,5 @@
 import { ObservableValue } from '@amazon/vinyl-observable';
-import { DashManifestData } from '../../track/dash/DashManifestProvider';
+import { DashManifestData } from './DashManifestProvider';
 import { AdaptationSetType, RepresentationType } from '@amazon/vinyl-mpd-parser';
 import { Comparator } from '@amazon/vinyl-util';
 export interface DashManifestTransformerDeps {

package/dist/types/ts3.7/track/dash/manifestTransformUtils.d.ts

@@ -1,5 +1,5 @@
 import { AdaptationSetType, DashManifest, RepresentationType } from '@amazon/vinyl-mpd-parser';
-import { DashManifestData } from '../../track/dash/DashManifestProvider';
+import { DashManifestData } from './DashManifestProvider';
 import { ObservableValue } from '@amazon/vinyl-observable';
 import { Comparator, FilterPredicate, MaybePromise } from '@amazon/vinyl-util';
 /**

package/dist/types/ts3.7/track/dash/timeline/DashRepresentationSegmentProvider.d.ts

@@ -1,9 +1,9 @@
 import { RepresentationType } from '@amazon/vinyl-mpd-parser';
-import { DashUriResolveDeps } from '../../../track/dash/util/uriResolution';
-import { CreateSegmentDataProviderDeps } from '../../../track/createSegmentDataProvider';
+import { DashUriResolveDeps } from '../util/uriResolution';
+import { CreateSegmentDataProviderDeps } from '../../createSegmentDataProvider';
 import { SegmentReference } from '../../../streaming/SegmentReference';
 import { SegmentDataProvider } from '../../../streaming/SegmentDataSlot';
-import { DashMediaQualityMetadataResolver } from '../../../track/dash/DashMediaQualityMetadataResolver';
+import { DashMediaQualityMetadataResolver } from '../DashMediaQualityMetadataResolver';
 export interface DashSegmentProviderDeps extends DashUriResolveDeps, CreateSegmentDataProviderDeps {
     /**
      * Produces abstract metadata from a dash representation.

package/dist/types/ts3.7/track/dash/urlDashManifestProvider.d.ts

@@ -1,7 +1,7 @@
 import { Maybe } from '@amazon/vinyl-util';
 import { RequestInitOptions } from '@amazon/vinyl-util';
 import { RequestInterceptor } from '@amazon/vinyl-util';
-import { DashManifestProvider } from '../../track/dash/DashManifestProvider';
+import { DashManifestProvider } from './DashManifestProvider';
 /**
  * Creates a DashManifestProvider which performs a request to retrieve a dash manifest.
  * Can be a relative path.

package/dist/types/ts3.7/track/dash/util/mpd.d.ts

@@ -74,7 +74,8 @@ export declare function getPeriodAtTime(manifest: DashManifest, time: number): P
 export declare function flattenRepresentations(period: PeriodType): RepresentationType[];
 /**
  * Calculates the manifest duration, either from the mediaPresentationDuration or the last period end time.
- * @param manifest
+ * Returns `Infinity` for live (dynamic) presentations.
+ * Throws if duration cannot be determined.
  */
-export declare function calculateDuration(manifest: DashManifest): number | null;
+export declare function calculateDuration(manifest: DashManifest): number;
 //# sourceMappingURL=mpd.d.ts.map

package/dist/types/ts3.7/track/hls/HlsManifestData.d.ts

@@ -0,0 +1,19 @@
+import { HlsMainPlaylist, HlsMediaPlaylist } from '@amazon/vinyl-hls-parser';
+export interface HlsManifestData {
+    /**
+     * The main HLS playlist manifest.
+     * Use getMediaPlaylist to resolve bitrate manifests.
+     */
+    readonly mainPlaylist: HlsMainPlaylist;
+    /**
+     * The URL to be used for relative requests. Guaranteed to be absolute.
+     *
+     * Media with relative paths in the manifests will be resolved relative to this URL.
+     */
+    readonly baseUrl: string;
+    /**
+     * Lazily fetches and caches a media playlist by variant URI.
+     */
+    readonly getMediaPlaylist: (uri: string) => Promise<HlsMediaPlaylist>;
+}
+//# sourceMappingURL=HlsManifestData.d.ts.map

package/dist/types/ts3.7/track/hls/buildHlsMediaTimeline.d.ts

@@ -1,7 +1,7 @@
-import { HlsManifestData } from '../../track/hls/HlsManifestProvider';
-import { HlsMediaQualityMetadataResolver } from '../../track/hls/HlsMediaQualityMetadataResolver';
+import { HlsManifestData } from './HlsManifestProvider';
+import { HlsMediaQualityMetadataResolver } from './HlsMediaQualityMetadataResolver';
 import { MediaTimeline } from '../../streaming/MediaTimeline';
-import { CreateSegmentDataProviderDeps } from '../../track/createSegmentDataProvider';
+import { CreateSegmentDataProviderDeps } from '../createSegmentDataProvider';
 export interface BuildHlsMediaTimelineDeps extends CreateSegmentDataProviderDeps {
     readonly mediaQualityMetadataResolver: HlsMediaQualityMetadataResolver;
 }

package/dist/types/ts3.7/track/hls/createDefaultHlsManifestTransformer.d.ts

@@ -1,5 +1,5 @@
 import { ObservableValue } from '@amazon/vinyl-observable';
-import { HlsManifestData } from '../../track/hls/HlsManifestProvider';
+import { HlsManifestData } from './HlsManifestProvider';
 export interface HlsManifestTransformerDeps {
     readonly manifestController: ObservableValue<Promise<HlsManifestData>>;
 }

package/dist/types/ts3.7/track/hls/createHlsManifestProvider.d.ts

@@ -0,0 +1,6 @@
+import { HlsTrackLoadOptions } from './HlsTrack';
+import { ManifestProvider } from '../../streaming/ManifestController';
+import { HlsManifestData } from './HlsManifestData';
+export declare function createHlsManifestProvider(loadOptions: HlsTrackLoadOptions): HlsManifestProvider;
+export type HlsManifestProvider = ManifestProvider<HlsManifestData>;
+//# sourceMappingURL=createHlsManifestProvider.d.ts.map

package/dist/types/ts3.7/track/hls/util/hlsSegmentTime.d.ts

@@ -1,7 +1,7 @@
 import { HlsSegment } from '@amazon/vinyl-hls-parser';
 import { MediaSegmentReference } from '../../../streaming/SegmentReference';
 import { SegmentDataProvider } from '../../../streaming/SegmentDataSlot';
-import { CreateSegmentDataProviderDeps } from '../../../track/createSegmentDataProvider';
+import { CreateSegmentDataProviderDeps } from '../../createSegmentDataProvider';
 /**
  * Builds a timeline of MediaSegmentReferences from an HLS media playlist's
  * segment list. Cumulative durations are used to compute start/end times.

package/dist/types/ts3.7/track/inferLoadOptionsFromUri.d.ts

@@ -0,0 +1,15 @@
+import { VinylTrackLoadOptions } from './createVinylTrackFactories';
+/**
+ * The built-in track types Vinyl can infer from a URI.
+ */
+export type TrackType = 'hls' | 'dash' | 'src';
+/**
+ * Infers the track type from a URI based first on its file extension
+ * then mime type.
+ *
+ * Returns null if the type cannot be determined.
+ */
+export declare function inferTrackTypeFromUrl(url: string): Promise<TrackType | null>;
+export declare function inferTrackTypeFromUrlPath(url: string): TrackType | null;
+export declare function createTrackLoadOptionsFromUrl(url: string): Promise<VinylTrackLoadOptions | null>;
+//# sourceMappingURL=inferLoadOptionsFromUri.d.ts.map

package/dist/types/ts3.7/track/mse/MseTrack.d.ts

@@ -1,6 +1,6 @@
-import { TrackBase, TrackBaseDeps, TrackBaseOptions } from '../../track/TrackBase';
+import { TrackBase, TrackBaseDeps, TrackBaseOptions } from '../TrackBase';
 import { ReadonlyRanges, ReadonlySet } from '@amazon/vinyl-util';
-import { TrackPreloadOptions, TrackTypeId, TrackUri } from '../../track/Track';
+import { TrackPreloadOptions, TrackTypeId, TrackUri } from '../Track';
 import { ContentType, MediaQualityMetadata } from '../../streaming/MediaQualityMetadata';
 import { Factories } from '@amazon/vinyl-di';
 import { ContentStream } from '../../streaming/ContentStream';

package/dist/types/ts3.7/track/source/FixedPlaybackQuality.d.ts

@@ -1,4 +1,4 @@
-import { TrackEventMap } from '../../track/Track';
+import { TrackEventMap } from '../Track';
 import { EventHostImpl, ReadonlySet } from '@amazon/vinyl-util';
 import { PlaybackController } from '../../playback/PlaybackController';
 import { ContentType, MediaQualityMetadata } from '../../streaming/MediaQualityMetadata';

package/dist/types/ts3.7/track/source/SourceObjectTrack.d.ts

@@ -1,9 +1,9 @@
 import { PlaybackSource } from '../../playback/PlaybackSource';
-import { TrackTypeId, TrackUri } from '../../track/Track';
-import { TrackBaseDeps } from '../../track/TrackBase';
-import { TrackFactory, TrackLoadOptions } from '../../track/TrackFactory';
+import { TrackTypeId, TrackUri } from '../Track';
+import { TrackBaseDeps } from '../TrackBase';
+import { TrackFactory, TrackLoadOptions } from '../TrackFactory';
 import { Maybe } from '@amazon/vinyl-util';
-import { SourceTrackBase, SourceTrackBaseOptions } from '../../track/source/SourceTrackBase';
+import { SourceTrackBase, SourceTrackBaseOptions } from './SourceTrackBase';
 /**
  * Dependencies for a SourceObjectTrack.
  */

package/dist/types/ts3.7/track/source/SourceTrack.d.ts

@@ -1,8 +1,8 @@
-import { TrackTypeId, TrackUri } from '../../track/Track';
-import { TrackBaseDeps } from '../../track/TrackBase';
-import { TrackFactory, TrackLoadOptions } from '../../track/TrackFactory';
+import { TrackTypeId, TrackUri } from '../Track';
+import { TrackBaseDeps } from '../TrackBase';
+import { TrackFactory, TrackLoadOptions } from '../TrackFactory';
 import { Maybe } from '@amazon/vinyl-util';
-import { SourceTrackBase, SourceTrackBaseOptions } from '../../track/source/SourceTrackBase';
+import { SourceTrackBase, SourceTrackBaseOptions } from './SourceTrackBase';
 import { PlaybackSource } from '../../playback/PlaybackSource';
 /**
  * Dependencies for a SourceTrack.

package/dist/types/ts3.7/track/source/SourceTrackBase.d.ts

@@ -1,5 +1,5 @@
-import { TrackBase, TrackBaseDeps, TrackBaseOptions } from '../../track/TrackBase';
-import { TrackEventMap, TrackPreloadOptions, TrackTypeId, TrackUri } from '../../track/Track';
+import { TrackBase, TrackBaseDeps, TrackBaseOptions } from '../TrackBase';
+import { TrackEventMap, TrackPreloadOptions, TrackTypeId, TrackUri } from '../Track';
 import { Maybe, ReadonlySet } from '@amazon/vinyl-util';
 import { ContentType, MediaQualityMetadata } from '../../streaming/MediaQualityMetadata';
 import { ObjectSchema } from '@amazon/vinyl-validation';

package/dist/types/ts3.7/util/media/codecOverrides.d.ts

@@ -0,0 +1,33 @@
+/**
+ * An explicit application-provided decision to allow or deny a codec,
+ * bypassing the browser's support detection.
+ *
+ *  - `'allow'` forces the codec to be treated as supported even if the browser
+ *    reports it unsupported (e.g. to opt in to a codec the app knows the
+ *    platform can decode via an external path).
+ *  - `'deny'` forces the codec to be treated as unsupported even if the browser
+ *    reports it supported (e.g. to work around a browser that falsely claims
+ *    support, or to exclude a codec by policy).
+ */
+export type CodecOverride = 'allow' | 'deny';
+/**
+ * Explicit codec allow/deny overrides. Keys are RFC 6381 codec strings or
+ * prefixes (matched case-insensitively against the start of each codec in a
+ * mimeType's `codecs=` list, so `"hvc1"` matches `"hvc1.2.20000000.L123.B0"`).
+ *
+ * An override supersedes the browser's support detection entirely. When a
+ * mimeType contains multiple codecs, a `'deny'` on any of them denies the
+ * mimeType; an `'allow'` applies only when no codec is denied.
+ */
+export type CodecOverrides = Readonly<Record<string, CodecOverride>>;
+/**
+ * Resolves the effective override decision for a mimeType against a set of
+ * {@link CodecOverrides}, or undefined when no override applies (in which case
+ * the caller should fall back to normal support detection).
+ *
+ * A `'deny'` on any contained codec wins over an `'allow'` on another, so an
+ * explicit deny is never silently overridden by an allow elsewhere in the
+ * mimeType.
+ */
+export declare function resolveCodecOverride(mimeType: string, overrides: CodecOverrides | undefined): CodecOverride | undefined;
+//# sourceMappingURL=codecOverrides.d.ts.map

package/dist/types/ts3.7/util/media/codecSupport.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Extracts the individual codec strings from a mimeType's `codecs=` parameter.
+ * Returns an empty array when no codecs parameter is present.
+ */
+export declare function extractCodecs(mimeType: string): string[];
+//# sourceMappingURL=codecSupport.d.ts.map

package/dist/types/ts3.7/util/media/mimeType.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Extracts the container subtype from a MIME type, lowercased — the portion
+ * after the `/`, ignoring any parameters. For example
+ * `video/webm; codecs="vp9"` → `webm` and `audio/mp4` → `mp4`. Returns an empty
+ * string when the MIME type has no subtype.
+ */
+export declare function mimeSubtype(mimeType: string): string;
+//# sourceMappingURL=mimeType.d.ts.map

package/dist/types/ts3.7/vinyl/VinylDeps.d.ts

@@ -7,7 +7,7 @@ import { TrackLoadOptions } from '../track/TrackFactory';
 import { DrmController } from '../drm/DrmController';
 import { AutoResetController } from '../track/AutoResetController';
 import { MutableValue } from '@amazon/vinyl-observable';
-import { VinylOptions } from '../vinyl/VinylOptions';
+import { VinylOptions } from './VinylOptions';
 export interface VinylDeps<TrackLoadOptionsType extends TrackLoadOptions = VinylTrackLoadOptions, OptionsType = VinylOptions> {
     /**
      * A mutable provider for configuration options.

package/dist/types/ts3.7/vinyl/VinylPlayer.d.ts

@@ -11,14 +11,28 @@ import { DefaultVinylFactories, InferVinylOverrideDependencyType, VinylDependenc
 import { VinylDeps } from './VinylDeps';
 import { Capabilities } from '../client/Capabilities';
 import { ContentType, MediaQualityMetadata } from '../streaming/MediaQualityMetadata';
-import { ReadonlyPlaybackStreamingState } from '../vinyl/ReadonlyPlaybackStreamingState';
+import { ReadonlyPlaybackStreamingState } from './ReadonlyPlaybackStreamingState';
 import { StreamingEventMap } from '../streaming/StreamingEventMap';
 import { InferObservableValueType } from '@amazon/vinyl-observable';
-import { VinylOptions } from '../vinyl/VinylOptions';
+import { VinylOptions } from './VinylOptions';
+import { ChangeEvent } from '../event/ChangeEvent';
 /**
  * Events the Vinyl Player emits.
  */
 export interface VinylPlayerEventMap<TrackLoadOptionsType extends TrackLoadOptions = VinylTrackLoadOptions> extends PlaybackControllerEventMap, TrackControllerEventMap<TrackLoadOptionsType>, StreamingEventMap {
+    /**
+     * Dispatched when {@link VinylPlayer.resetPending} changes.
+     *
+     * `current` is true when the player has hit a transient, potentially
+     * recoverable error (e.g. a network outage) and an automatic reset
+     * attempt is scheduled. `current` is false once the pending reset is
+     * emitted, the error is cleared, or all retries are exhausted.
+     *
+     * If `resetPending` becomes false while {@link VinylPlayer.error} is
+     * still non-null, all automatic reset attempts have been exhausted
+     * and playback will not recover without user action.
+     */
+    readonly resetPendingChange: ChangeEvent<boolean>;
 }
 /**
  * A Vinyl Media Player.
@@ -32,6 +46,7 @@ export declare class VinylPlayer<TrackLoadOptionsType extends TrackLoadOptions =
     private get drmController();
     private get playbackController();
     private get trackController();
+    private get autoResetController();
     /**
      * Provides information about the client, such as device and browser capabilities.
      */
@@ -74,6 +89,7 @@ export declare class VinylPlayer<TrackLoadOptionsType extends TrackLoadOptions =
     get duration(): number;
     get ended(): boolean;
     get error(): (Error | null);
+    get resetPending(): boolean;
     get hasMetadata(): boolean;
     get loop(): boolean;
     set loop(value: boolean);

package/dist/types/ts3.7/vinyl/createVinylFactories.d.ts

@@ -18,7 +18,7 @@ import { LoudnessNormalizationControllerImpl } from '../playback/loudness/Loudne
 import { AutoResetControllerImpl, AutoResetControllerImplDeps, AutoResetControllerImplOptions } from '../track/AutoResetController';
 import { Dependencies, Factories } from '@amazon/vinyl-di';
 import { ContentStreamingOptions } from '../streaming/ContentStreamingOptions';
-import { VinylOptions } from '../vinyl/VinylOptions';
+import { VinylOptions } from './VinylOptions';
 import { ObservableValue } from '@amazon/vinyl-observable';
 /**
  * Configuration used by the default dependency factories for Vinyl.
@@ -81,15 +81,13 @@ export declare function createVinylFactories(options: VinylDependencyOptions): {
     }) => LoudnessNormalizationControllerImpl;
     capabilities: (deps: CapabilitiesImplDeps) => CapabilitiesImpl;
     requestInterceptor: () => typeof noop;
-    trackFactory: (deps: VinylTrackFactoryDeps) => import("../track/TrackFactory").TrackFactory<import("..").SourceObjectTrackLoadOptions | import("..").SourceTrackLoadOptions | import("..").DashTrackLoadOptions | import("..").HlsTrackLoadOptions>;
+    trackFactory: (deps: VinylTrackFactoryDeps) => import("..").TrackFactory<import("..").SourceObjectTrackLoadOptions | import("..").SourceTrackLoadOptions | import("..").DashTrackLoadOptions | import("..").HlsTrackLoadOptions>;
     trackController: (deps: TrackControllerImplDeps<any>) => TrackControllerImpl<any>;
-    drmKeySystemResolver: () => import("../drm/DrmKeySystemResolver").DrmKeySystemResolver;
+    drmKeySystemResolver: () => import("..").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) => {
+    createDashFactories: (deps: import("..").DashFactoryDeps) => (loadOptions: import("..").DashTrackLoadOptions) => {
         contentTypesValue: typeof import("..").createDashContentTypesValue;
         baseUrlSelector: () => import("..").BaseUrlSelector;
         segmentRequestInit: () => import("@amazon/vinyl-util").Maybe<Readonly<Omit<RequestInit, "signal">>>;
@@ -112,7 +110,7 @@ export declare function createVinylFactories(options: VinylDependencyOptions): {
         contentStreamFactory: typeof import("..").createContentStreamFactory;
         qualitySelector: (deps: {
             options: ObservableValue<Pick<VinylOptions, "abr">>;
-        }) => import("../streaming/abr/QualitySelectorImpl").QualitySelectorImpl;
+        }) => import("..").QualitySelectorImpl;
         manifestTransformed: typeof import("..").createDefaultDashManifestTransformer;
         mediaTimeline: (deps: import("..").BuildDashMediaTimelineDeps & {
             readonly manifestTransformed: ObservableValue<Promise<import("..").DashManifestData>>;
@@ -124,12 +122,12 @@ export declare function createVinylFactories(options: VinylDependencyOptions): {
         }>>;
         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>;
+        drmKeySystemResolver: import("@amazon/vinyl-di").Factory<import("..").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) => {
+    createHlsFactories: (deps: import("..").HlsFactoryDeps) => (loadOptions: import("..").HlsTrackLoadOptions) => {
         contentTypesValue: typeof import("..").createHlsContentTypesValue;
         manifestController: () => import("..").HlsManifestControllerImpl;
         manifestTransformed: typeof import("..").createDefaultHlsManifestTransformer;
@@ -149,7 +147,7 @@ export declare function createVinylFactories(options: VinylDependencyOptions): {
         contentStreamFactory: typeof import("..").createContentStreamFactory;
         qualitySelector: (deps: {
             options: ObservableValue<Pick<VinylOptions, "abr">>;
-        }) => import("../streaming/abr/QualitySelectorImpl").QualitySelectorImpl;
+        }) => import("..").QualitySelectorImpl;
         mediaTimeline: (deps: import("..").BuildHlsMediaTimelineDeps & {
             readonly manifestTransformed: ObservableValue<Promise<import("..").HlsManifestData>>;
         }) => ObservableValue<Promise<import("..").MediaTimeline>>;
@@ -160,7 +158,7 @@ export declare function createVinylFactories(options: VinylDependencyOptions): {
         }>>;
         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>;
+        drmKeySystemResolver: import("@amazon/vinyl-di").Factory<import("..").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>;