rx-player 3.26.1 → 3.26.2

package/dist/_esm5.processed/core/init/emit_loaded_event.d.ts

@@ -14,14 +14,15 @@
  * limitations under the License.
  */
 import { Observable } from "rxjs";
+import { IPlaybackObservation } from "../api";
 import SegmentBuffersStore from "../segment_buffers";
-import { IInitClockTick, ILoadedEvent } from "./types";
+import { ILoadedEvent } from "./types";
 /**
  * Emit a `ILoadedEvent` once the content can be considered as loaded.
- * @param {Observable} clock$
+ * @param {Observable} observation$
  * @param {HTMLMediaElement} mediaElement
  * @param {Object|null} segmentBuffersStore
  * @param {boolean} isDirectfile - `true` if this is a directfile content
  * @returns {Observable}
  */
-export default function emitLoadedEvent(clock$: Observable<IInitClockTick>, mediaElement: HTMLMediaElement, segmentBuffersStore: SegmentBuffersStore | null, isDirectfile: boolean): Observable<ILoadedEvent>;
+export default function emitLoadedEvent(observation$: Observable<IPlaybackObservation>, mediaElement: HTMLMediaElement, segmentBuffersStore: SegmentBuffersStore | null, isDirectfile: boolean): Observable<ILoadedEvent>;

package/dist/_esm5.processed/core/init/emit_loaded_event.js

@@ -13,30 +13,30 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { take, } from "rxjs/operators";
+import { take, } from "rxjs";
 import { shouldValidateMetadata, shouldWaitForDataBeforeLoaded, } from "../../compat";
 import filterMap from "../../utils/filter_map";
 import EVENTS from "./events_generators";
 /**
  * Emit a `ILoadedEvent` once the content can be considered as loaded.
- * @param {Observable} clock$
+ * @param {Observable} observation$
  * @param {HTMLMediaElement} mediaElement
  * @param {Object|null} segmentBuffersStore
  * @param {boolean} isDirectfile - `true` if this is a directfile content
  * @returns {Observable}
  */
-export default function emitLoadedEvent(clock$, mediaElement, segmentBuffersStore, isDirectfile) {
-    return clock$.pipe(filterMap(function (tick) {
-        if (tick.rebuffering !== null ||
-            tick.freezing !== null ||
-            tick.readyState === 0) {
+export default function emitLoadedEvent(observation$, mediaElement, segmentBuffersStore, isDirectfile) {
+    return observation$.pipe(filterMap(function (observation) {
+        if (observation.rebuffering !== null ||
+            observation.freezing !== null ||
+            observation.readyState === 0) {
             return null;
         }
         if (!shouldWaitForDataBeforeLoaded(isDirectfile, mediaElement.hasAttribute("playsinline"))) {
             return mediaElement.duration > 0 ? EVENTS.loaded(segmentBuffersStore) :
                 null;
         }
-        if (tick.readyState >= 3 && tick.currentRange !== null) {
+        if (observation.readyState >= 3 && observation.currentRange !== null) {
             if (!shouldValidateMetadata() || mediaElement.duration > 0) {
                 return EVENTS.loaded(segmentBuffersStore);
             }

package/dist/_esm5.processed/core/init/end_of_stream.js

@@ -13,8 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { defer as observableDefer, merge as observableMerge, of as observableOf, race as observableRace, } from "rxjs";
-import { mergeMap, startWith, switchMap, take, takeLast, } from "rxjs/operators";
+import { defer as observableDefer, merge as observableMerge, mergeMap, of as observableOf, race as observableRace, startWith, switchMap, take, takeLast, } from "rxjs";
 import { events } from "../../compat";
 import log from "../../log";
 var onRemoveSourceBuffers$ = events.onRemoveSourceBuffers$, onSourceOpen$ = events.onSourceOpen$, onUpdate$ = events.onUpdate$;

package/dist/_esm5.processed/core/init/get_initial_time.js

@@ -30,7 +30,6 @@ var DEFAULT_LIVE_GAP = config.DEFAULT_LIVE_GAP;
  * @returns {Number}
  */
 export default function getInitialTime(manifest, lowLatencyMode, startAt) {
-    log.debug("Init: calculating initial time");
     if (startAt != null) {
         var min = manifest.getMinimumPosition();
         var max = manifest.getMaximumPosition();
@@ -94,8 +93,8 @@ export default function getInitialTime(manifest, lowLatencyMode, startAt) {
         var diffFromLiveTime = suggestedPresentationDelay !== undefined ? suggestedPresentationDelay :
             lowLatencyMode ? DEFAULT_LIVE_GAP.LOW_LATENCY :
                 DEFAULT_LIVE_GAP.DEFAULT;
-        log.debug("Init: " + liveTime + " defined as the live time, applying a live gap" +
-            (" of " + diffFromLiveTime));
+        log.debug("Init: ".concat(liveTime, " defined as the live time, applying a live gap") +
+            " of ".concat(diffFromLiveTime));
         return Math.max(liveTime - diffFromLiveTime, minimumPosition);
     }
     log.info("Init: starting at the minimum available position:", minimumPosition);

package/dist/_esm5.processed/core/init/initial_seek_and_play.d.ts

@@ -14,7 +14,9 @@
  * limitations under the License.
  */
 import { Observable } from "rxjs";
-import { IInitClockTick, IWarningEvent } from "./types";
+import { IReadOnlySharedReference } from "../../utils/reference";
+import { IPlaybackObservation, PlaybackObserver } from "../api";
+import { IWarningEvent } from "./types";
 /** Event emitted when trying to perform the initial `play`. */
 export declare type IInitialPlayEvent = 
 /** Autoplay is not enabled, but all required steps to do so are there. */
@@ -35,46 +37,45 @@ export declare type IInitialPlayEvent =
 /** Warnings preventing the initial play from happening normally. */
 IWarningEvent;
 /**
- * Emit once as soon as the clock$ announce that the content can begin to be
- * played by calling the `play` method.
+ * Emit once as soon as the playback observation announces that the content can
+ * begin to be played by calling the `play` method.
  *
  * This depends on browser-defined criteria (e.g. the readyState status) as well
  * as RxPlayer-defined ones (e.g.) not rebuffering.
  *
- * @param {Observable} clock$
+ * @param {Observable} observation$
  * @returns {Observable.<undefined>}
  */
-export declare function waitUntilPlayable(clock$: Observable<IInitClockTick>): Observable<undefined>;
+export declare function waitUntilPlayable(observation$: Observable<IPlaybackObservation>): Observable<undefined>;
+/** Object returned by `initialSeekAndPlay`. */
+export interface IInitialSeekAndPlayObject {
+    /**
+     * Observable which, when subscribed, will try to seek at the initial position
+     * then play if needed as soon as the HTMLMediaElement's properties are right.
+     *
+     * Emits various events relative to the status of this operation.
+     */
+    seekAndPlay$: Observable<IInitialPlayEvent>;
+    /**
+     * Shared reference whose value becomes `true` once the initial seek has
+     * been considered / has been done by `seekAndPlay$`.
+     */
+    initialSeekPerformed: IReadOnlySharedReference<boolean>;
+    /**
+     * Shared reference whose value becomes `true` once the initial play has
+     * been considered / has been done by `seekAndPlay$`.
+     */
+    initialPlayPerformed: IReadOnlySharedReference<boolean>;
+}
 /**
- * Returns two Observables:
- *
- *   - seek$: when subscribed, will seek to the wanted started time as soon as
- *     it can. Emit and complete when done.
- *
- *   - play$: when subscribed, will autoplay if and only if the `mustAutoPlay`
- *     option is set as soon as it can.
- *     Emit and complete when done.
- *     Might also emit some warning events if issues related to the initial
- *     playback arised
- *
- * Both Observables are `shareReplay`, meaning that they re-emit everything on
- * subscription.
- *
- * /!\ `play$` has a dependency on `seek$`, as such, the player will try to seek
- * as soon as either Observable is subscribed to.
- *
+ * Creates an Observable allowing to seek at the initially wanted position and
+ * to play if autoPlay is wanted.
  * @param {Object} args
  * @returns {Object}
  */
-export default function initialSeekAndPlay({ clock$, mediaElement, startTime, mustAutoPlay, setCurrentTime }: {
-    clock$: Observable<IInitClockTick>;
-    isDirectfile: boolean;
+export default function initialSeekAndPlay({ mediaElement, playbackObserver, startTime, mustAutoPlay }: {
+    playbackObserver: PlaybackObserver;
     mediaElement: HTMLMediaElement;
     mustAutoPlay: boolean;
-    /** Perform an internal seek. */
-    setCurrentTime: (nb: number) => void;
     startTime: number | (() => number);
-}): {
-    seek$: Observable<unknown>;
-    play$: Observable<IInitialPlayEvent>;
-};
+}): IInitialSeekAndPlayObject;

package/dist/_esm5.processed/core/init/initial_seek_and_play.js

@@ -13,29 +13,29 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { concat as observableConcat, of as observableOf, } from "rxjs";
-import { catchError, filter, mapTo, mergeMap, shareReplay, startWith, take, tap, } from "rxjs/operators";
+import { catchError, concat as observableConcat, filter, map, mergeMap, of as observableOf, shareReplay, startWith, take, tap, } from "rxjs";
 import { play, shouldValidateMetadata, whenLoadedMetadata$, } from "../../compat";
 import { MediaError } from "../../errors";
 import log from "../../log";
+import { createSharedReference, } from "../../utils/reference";
 import EVENTS from "./events_generators";
 /**
- * Emit once as soon as the clock$ announce that the content can begin to be
- * played by calling the `play` method.
+ * Emit once as soon as the playback observation announces that the content can
+ * begin to be played by calling the `play` method.
  *
  * This depends on browser-defined criteria (e.g. the readyState status) as well
  * as RxPlayer-defined ones (e.g.) not rebuffering.
  *
- * @param {Observable} clock$
+ * @param {Observable} observation$
  * @returns {Observable.<undefined>}
  */
-export function waitUntilPlayable(clock$) {
-    return clock$.pipe(filter(function (_a) {
+export function waitUntilPlayable(observation$) {
+    return observation$.pipe(filter(function (_a) {
         var seeking = _a.seeking, rebuffering = _a.rebuffering, readyState = _a.readyState;
         return !seeking &&
             rebuffering === null &&
             readyState >= 1;
-    }), take(1), mapTo(undefined));
+    }), take(1), map(function () { return undefined; }));
 }
 /**
  * Try to play content then handle autoplay errors.
@@ -43,7 +43,7 @@ export function waitUntilPlayable(clock$) {
  * @returns {Observable}
  */
 function autoPlay(mediaElement) {
-    return play(mediaElement).pipe(mapTo("autoplay"), catchError(function (error) {
+    return play(mediaElement).pipe(map(function () { return "autoplay"; }), catchError(function (error) {
         if (error instanceof Error && error.name === "NotAllowedError") {
             // auto-play was probably prevented.
             log.warn("Init: Media element can't play." +
@@ -56,42 +56,31 @@ function autoPlay(mediaElement) {
     }));
 }
 /**
- * Returns two Observables:
- *
- *   - seek$: when subscribed, will seek to the wanted started time as soon as
- *     it can. Emit and complete when done.
- *
- *   - play$: when subscribed, will autoplay if and only if the `mustAutoPlay`
- *     option is set as soon as it can.
- *     Emit and complete when done.
- *     Might also emit some warning events if issues related to the initial
- *     playback arised
- *
- * Both Observables are `shareReplay`, meaning that they re-emit everything on
- * subscription.
- *
- * /!\ `play$` has a dependency on `seek$`, as such, the player will try to seek
- * as soon as either Observable is subscribed to.
- *
+ * Creates an Observable allowing to seek at the initially wanted position and
+ * to play if autoPlay is wanted.
  * @param {Object} args
  * @returns {Object}
  */
 export default function initialSeekAndPlay(_a) {
-    var clock$ = _a.clock$, mediaElement = _a.mediaElement, startTime = _a.startTime, mustAutoPlay = _a.mustAutoPlay, setCurrentTime = _a.setCurrentTime;
+    var mediaElement = _a.mediaElement, playbackObserver = _a.playbackObserver, startTime = _a.startTime, mustAutoPlay = _a.mustAutoPlay;
+    var initialSeekPerformed = createSharedReference(false);
+    var initialPlayPerformed = createSharedReference(false);
     var seek$ = whenLoadedMetadata$(mediaElement).pipe(take(1), tap(function () {
         log.info("Init: Set initial time", startTime);
         var initialTime = typeof startTime === "function" ? startTime() :
             startTime;
-        setCurrentTime(initialTime);
+        playbackObserver.setCurrentTime(initialTime);
+        initialSeekPerformed.setValue(true);
+        initialSeekPerformed.finish();
     }), shareReplay({ refCount: true }));
-    var play$ = seek$.pipe(mergeMap(function () {
+    var seekAndPlay$ = seek$.pipe(mergeMap(function () {
         if (!shouldValidateMetadata() || mediaElement.duration > 0) {
-            return waitUntilPlayable(clock$);
+            return waitUntilPlayable(playbackObserver.observe(true));
         }
         else {
             var error = new MediaError("MEDIA_ERR_NOT_LOADED_METADATA", "Cannot load automatically: your browser " +
                 "falsely announced having loaded the content.");
-            return waitUntilPlayable(clock$)
+            return waitUntilPlayable(playbackObserver.observe(true))
                 .pipe(startWith(EVENTS.warning(error)));
         }
     }), mergeMap(function (evt) {
@@ -104,9 +93,13 @@ export default function initialSeekAndPlay(_a) {
                 log.warn("Init: autoplay is enabled on HTML media element. " +
                     "Media will play as soon as possible.");
             }
+            initialPlayPerformed.setValue(true);
+            initialPlayPerformed.finish();
             return observableOf({ type: "skipped" });
         }
         return autoPlay(mediaElement).pipe(mergeMap(function (autoplayEvt) {
+            initialPlayPerformed.setValue(true);
+            initialPlayPerformed.finish();
             if (autoplayEvt === "autoplay") {
                 return observableOf({ type: "autoplay" });
             }
@@ -117,5 +110,5 @@ export default function initialSeekAndPlay(_a) {
             }
         }));
     }), shareReplay({ refCount: true }));
-    return { seek$: seek$, play$: play$ };
+    return { seekAndPlay$: seekAndPlay$, initialPlayPerformed: initialPlayPerformed, initialSeekPerformed: initialSeekPerformed };
 }

package/dist/_esm5.processed/core/init/initialize_directfile.d.ts

@@ -18,16 +18,17 @@
  * It always should be imported through the `features` object.
  */
 import { Observable } from "rxjs";
+import { IReadOnlySharedReference } from "../../utils/reference";
+import { PlaybackObserver } from "../api";
 import { IKeySystemOption } from "../eme";
 import { IInitialTimeOptions } from "./get_initial_time";
-import { IDirectfileEvent, IInitClockTick } from "./types";
+import { IDirectfileEvent } from "./types";
 export interface IDirectFileOptions {
     autoPlay: boolean;
-    clock$: Observable<IInitClockTick>;
     keySystems: IKeySystemOption[];
     mediaElement: HTMLMediaElement;
-    speed$: Observable<number>;
-    setCurrentTime: (nb: number) => void;
+    playbackObserver: PlaybackObserver;
+    speed: IReadOnlySharedReference<number>;
     startAt?: IInitialTimeOptions;
     url?: string;
 }
@@ -36,5 +37,5 @@ export interface IDirectFileOptions {
  * @param {Object} directfileOptions
  * @returns {Observable}
  */
-export default function initializeDirectfileContent({ autoPlay, clock$, keySystems, mediaElement, speed$, setCurrentTime, startAt, url, }: IDirectFileOptions): Observable<IDirectfileEvent>;
+export default function initializeDirectfileContent({ autoPlay, keySystems, mediaElement, playbackObserver, speed, startAt, url, }: IDirectFileOptions): Observable<IDirectfileEvent>;
 export { IDirectfileEvent };

package/dist/_esm5.processed/core/init/initialize_directfile.js

@@ -17,8 +17,7 @@
  * /!\ This file is feature-switchable.
  * It always should be imported through the `features` object.
  */
-import { EMPTY, merge as observableMerge, of as observableOf, } from "rxjs";
-import { filter, ignoreElements, mergeMap, mergeMapTo, switchMap, share, take, } from "rxjs/operators";
+import { EMPTY, filter, ignoreElements, merge as observableMerge, mergeMap, switchMap, of as observableOf, share, take, } from "rxjs";
 import { clearElementSrc, setElementSrc$, } from "../../compat";
 import log from "../../log";
 import deferSubscriptions from "../../utils/defer_subscriptions";
@@ -75,7 +74,7 @@ function getDirectFileInitialTime(mediaElement, startAt) {
  * @returns {Observable}
  */
 export default function initializeDirectfileContent(_a) {
-    var autoPlay = _a.autoPlay, clock$ = _a.clock$, keySystems = _a.keySystems, mediaElement = _a.mediaElement, speed$ = _a.speed$, setCurrentTime = _a.setCurrentTime, startAt = _a.startAt, url = _a.url;
+    var autoPlay = _a.autoPlay, keySystems = _a.keySystems, mediaElement = _a.mediaElement, playbackObserver = _a.playbackObserver, speed = _a.speed, startAt = _a.startAt, url = _a.url;
     clearElementSrc(mediaElement);
     if (url == null) {
         throw new Error("No URL for a DirectFile content");
@@ -85,23 +84,29 @@ export default function initializeDirectfileContent(_a) {
     log.debug("Init: Calculating initial time");
     var initialTime = function () { return getDirectFileInitialTime(mediaElement, startAt); };
     log.debug("Init: Initial time calculated:", initialTime);
-    var _b = initialSeekAndPlay({ clock$: clock$, mediaElement: mediaElement, startTime: initialTime,
-        mustAutoPlay: autoPlay, setCurrentTime: setCurrentTime, isDirectfile: true }), seek$ = _b.seek$, play$ = _b.play$;
+    var seekAndPlay$ = initialSeekAndPlay({ mediaElement: mediaElement, playbackObserver: playbackObserver, startTime: initialTime,
+        mustAutoPlay: autoPlay }).seekAndPlay$;
     // Create EME Manager, an observable which will manage every EME-related
     // issue.
     var emeManager$ = linkURL$.pipe(mergeMap(function () { return createEMEManager(mediaElement, keySystems, EMPTY); }), deferSubscriptions(), share());
     // Translate errors coming from the media element into RxPlayer errors
     // through a throwing Observable.
     var mediaError$ = throwOnMediaError(mediaElement);
+    var observation$ = playbackObserver.observe(true);
     // Set the speed set by the user on the media element while pausing a
     // little longer while the buffer is empty.
-    var playbackRate$ = updatePlaybackRate(mediaElement, speed$, clock$)
+    var playbackRate$ = updatePlaybackRate(mediaElement, speed, observation$)
+        // NOTE As of now (RxJS 7.4.0), RxJS defines `ignoreElements` default
+        // first type parameter as `any` instead of the perfectly fine `unknown`,
+        // leading to linter issues, as it forbids the usage of `any`.
+        // This is why we're disabling the eslint rule.
+        /* eslint-disable-next-line @typescript-eslint/no-unsafe-argument */
         .pipe(ignoreElements());
     /**
      * Observable trying to avoid various stalling situations, emitting "stalled"
      * events when it cannot, as well as "unstalled" events when it get out of one.
      */
-    var stallAvoider$ = StallAvoider(clock$, mediaElement, null, EMPTY, EMPTY, setCurrentTime);
+    var stallAvoider$ = StallAvoider(playbackObserver, null, EMPTY, EMPTY);
     /**
      * Emit a "loaded" events once the initial play has been performed and the
      * media can begin playback.
@@ -109,16 +114,15 @@ export default function initializeDirectfileContent(_a) {
      */
     var loadingEvts$ = emeManager$.pipe(filter(function isEMEReady(evt) {
         if (evt.type === "created-media-keys") {
-            evt.value.attachMediaKeys$.next();
+            evt.value.canAttachMediaKeys.setValue(true);
             return true;
         }
         return evt.type === "eme-disabled" || evt.type === "attached-media-keys";
-    }), take(1), mergeMapTo(play$), switchMap(function (evt) {
+    }), take(1), mergeMap(function () { return seekAndPlay$; }), switchMap(function (evt) {
         if (evt.type === "warning") {
             return observableOf(evt);
         }
-        return emitLoadedEvent(clock$, mediaElement, null, true);
+        return emitLoadedEvent(observation$, mediaElement, null, true);
     }));
-    var initialSeek$ = seek$.pipe(ignoreElements());
-    return observableMerge(loadingEvts$, initialSeek$, emeManager$, mediaError$, playbackRate$, stallAvoider$);
+    return observableMerge(loadingEvts$, emeManager$, mediaError$, playbackRate$, stallAvoider$);
 }

package/dist/_esm5.processed/core/init/initialize_media_source.d.ts

@@ -13,13 +13,15 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { BehaviorSubject, Observable } from "rxjs";
+import { Observable } from "rxjs";
+import { IReadOnlySharedReference } from "../../utils/reference";
 import { IABRManagerArguments } from "../abr";
+import { PlaybackObserver } from "../api";
 import { IKeySystemOption } from "../eme";
 import { IManifestFetcherParsedResult, IManifestFetcherWarningEvent, ManifestFetcher, SegmentFetcherCreator } from "../fetchers";
 import { ITextTrackSegmentBufferOptions } from "../segment_buffers";
 import { IInitialTimeOptions } from "./get_initial_time";
-import { IInitClockTick, IInitEvent } from "./types";
+import { IInitEvent } from "./types";
 /** Arguments to give to the `InitializeOnMediaSource` function. */
 export interface IInitializeArguments {
     /** Options concerning the ABR logic. */
@@ -29,11 +31,11 @@ export interface IInitializeArguments {
     /** Options concerning the media buffers. */
     bufferOptions: {
         /** Buffer "goal" at which we stop downloading new segments. */
-        wantedBufferAhead$: BehaviorSubject<number>;
+        wantedBufferAhead: IReadOnlySharedReference<number>;
         /** Max buffer size after the current position, in seconds (we GC further up). */
-        maxBufferAhead$: Observable<number>;
+        maxBufferAhead: IReadOnlySharedReference<number>;
         /** Max buffer size before the current position, in seconds (we GC further down). */
-        maxBufferBehind$: Observable<number>;
+        maxBufferBehind: IReadOnlySharedReference<number>;
         /** Strategy when switching the current bitrate manually (smooth vs reload). */
         manualBitrateSwitchingMode: "seamless" | "direct";
         /**
@@ -47,7 +49,7 @@ export interface IInitializeArguments {
         onCodecSwitch: "continue" | "reload";
     };
     /** Regularly emit current playback conditions. */
-    clock$: Observable<IInitClockTick>;
+    playbackObserver: PlaybackObserver;
     /** Every encryption configuration set. */
     keySystems: IKeySystemOption[];
     /** `true` to play low-latency contents optimally. */
@@ -62,10 +64,8 @@ export interface IInitializeArguments {
     minimumManifestUpdateInterval: number;
     /** Interface allowing to load segments */
     segmentFetcherCreator: SegmentFetcherCreator;
-    /** Perform an internal seek */
-    setCurrentTime: (time: number) => void;
     /** Emit the playback rate (speed) set by the user. */
-    speed$: Observable<number>;
+    speed: IReadOnlySharedReference<number>;
     /** The configured starting position. */
     startAt?: IInitialTimeOptions;
     /** Configuration specific to the text track. */
@@ -102,4 +102,4 @@ export interface IInitializeArguments {
  * @param {Object} args
  * @returns {Observable}
  */
-export default function InitializeOnMediaSource({ adaptiveOptions, autoPlay, bufferOptions, clock$, keySystems, lowLatencyMode, manifest$, manifestFetcher, mediaElement, minimumManifestUpdateInterval, segmentFetcherCreator, setCurrentTime, speed$, startAt, textTrackOptions }: IInitializeArguments): Observable<IInitEvent>;
+export default function InitializeOnMediaSource({ adaptiveOptions, autoPlay, bufferOptions, keySystems, lowLatencyMode, manifest$, manifestFetcher, mediaElement, minimumManifestUpdateInterval, playbackObserver, segmentFetcherCreator, speed, startAt, textTrackOptions }: IInitializeArguments): Observable<IInitEvent>;

package/dist/_esm5.processed/core/init/initialize_media_source.js

@@ -13,8 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { combineLatest as observableCombineLatest, EMPTY, merge as observableMerge, of as observableOf, Subject, } from "rxjs";
-import { exhaustMap, filter, finalize, ignoreElements, map, mapTo, mergeMap, mergeScan, share, shareReplay, startWith, switchMap, take, takeUntil, tap, } from "rxjs/operators";
+import { combineLatest as observableCombineLatest, EMPTY, exhaustMap, filter, finalize, ignoreElements, map, merge as observableMerge, mergeMap, mergeScan, of as observableOf, share, shareReplay, startWith, Subject, switchMap, take, takeUntil, tap, } from "rxjs";
 import { shouldReloadMediaSourceOnDecipherabilityUpdate } from "../../compat";
 import config from "../../config";
 import log from "../../log";
@@ -64,7 +63,7 @@ var OUT_OF_SYNC_MANIFEST_REFRESH_DELAY = config.OUT_OF_SYNC_MANIFEST_REFRESH_DEL
  * @returns {Observable}
  */
 export default function InitializeOnMediaSource(_a) {
-    var adaptiveOptions = _a.adaptiveOptions, autoPlay = _a.autoPlay, bufferOptions = _a.bufferOptions, clock$ = _a.clock$, keySystems = _a.keySystems, lowLatencyMode = _a.lowLatencyMode, manifest$ = _a.manifest$, manifestFetcher = _a.manifestFetcher, mediaElement = _a.mediaElement, minimumManifestUpdateInterval = _a.minimumManifestUpdateInterval, segmentFetcherCreator = _a.segmentFetcherCreator, setCurrentTime = _a.setCurrentTime, speed$ = _a.speed$, startAt = _a.startAt, textTrackOptions = _a.textTrackOptions;
+    var adaptiveOptions = _a.adaptiveOptions, autoPlay = _a.autoPlay, bufferOptions = _a.bufferOptions, keySystems = _a.keySystems, lowLatencyMode = _a.lowLatencyMode, manifest$ = _a.manifest$, manifestFetcher = _a.manifestFetcher, mediaElement = _a.mediaElement, minimumManifestUpdateInterval = _a.minimumManifestUpdateInterval, playbackObserver = _a.playbackObserver, segmentFetcherCreator = _a.segmentFetcherCreator, speed = _a.speed, startAt = _a.startAt, textTrackOptions = _a.textTrackOptions;
     /** Choose the right "Representation" for a given "Adaptation". */
     var abrManager = new ABRManager(adaptiveOptions);
     /**
@@ -115,10 +114,12 @@ export default function InitializeOnMediaSource(_a) {
                 return openMediaSource$.pipe(mergeMap(function () {
                     // Now that the MediaSource has been opened and linked to the media
                     // element we can attach the MediaKeys instance to the latter.
-                    evt.value.attachMediaKeys$.next();
+                    evt.value.canAttachMediaKeys.setValue(true);
                     // If the `disableMediaKeysAttachmentLock` option has been set to
                     // `true`, we should not wait until the MediaKeys instance has been
                     // attached to start loading the content.
+                    // TODO we may want to keep keySystems option knowledge in the EME
+                    // code
                     var shouldDisableLock = evt.value.options
                         .disableMediaKeysAttachmentLock === true;
                     return shouldDisableLock ? observableOf({ isEmeReady: true, drmSystemId: drmSystemId_1 }) :
@@ -147,12 +148,11 @@ export default function InitializeOnMediaSource(_a) {
         var mediaSourceLoader = createMediaSourceLoader({
             abrManager: abrManager,
             bufferOptions: objectAssign({ textTrackOptions: textTrackOptions, drmSystemId: drmSystemId }, bufferOptions),
-            clock$: clock$,
             manifest: manifest,
             mediaElement: mediaElement,
+            playbackObserver: playbackObserver,
             segmentFetcherCreator: segmentFetcherCreator,
-            speed$: speed$,
-            setCurrentTime: setCurrentTime,
+            speed: speed,
         });
         // handle initial load and reloads
         var recursiveLoad$ = recursivelyLoadOnMediaSource(initialMediaSource, initialTime, autoPlay);
@@ -160,7 +160,7 @@ export default function InitializeOnMediaSource(_a) {
         var scheduleRefresh$ = new Subject();
         var manifestUpdate$ = manifestUpdateScheduler({ initialManifest: manifestEvt, manifestFetcher: manifestFetcher, minimumManifestUpdateInterval: minimumManifestUpdateInterval, scheduleRefresh$: scheduleRefresh$ });
         var manifestEvents$ = observableMerge(fromEvent(manifest, "manifestUpdate")
-            .pipe(mapTo(EVENTS.manifestUpdate())), fromEvent(manifest, "decipherabilityUpdate")
+            .pipe(map(function () { return EVENTS.manifestUpdate(); })), fromEvent(manifest, "decipherabilityUpdate")
             .pipe(map(EVENTS.decipherabilityUpdate)));
         var setUndecipherableRepresentations$ = emeManager$.pipe(tap(function (evt) {
             if (evt.type === "keys-update") {
@@ -170,7 +170,13 @@ export default function InitializeOnMediaSource(_a) {
                 log.info("Init: blacklisting Representations based on protection data.");
                 manifest.addUndecipherableProtectionData(evt.value);
             }
-        }), ignoreElements());
+        }), 
+        // NOTE As of now (RxJS 7.4.0), RxJS defines `ignoreElements` default
+        // first type parameter as `any` instead of the perfectly fine `unknown`,
+        // leading to linter issues, as it forbids the usage of `any`.
+        // This is why we're disabling the eslint rule.
+        /* eslint-disable-next-line @typescript-eslint/no-unsafe-argument */
+        ignoreElements());
         return observableMerge(manifestEvents$, manifestUpdate$, setUndecipherableRepresentations$, recursiveLoad$)
             .pipe(startWith(EVENTS.manifestReady(manifest)), finalize(function () { scheduleRefresh$.complete(); }));
         /**
@@ -212,17 +218,17 @@ export default function InitializeOnMediaSource(_a) {
                         // to flush the buffers
                         var position = evt.value.position;
                         if (position + 0.001 < evt.value.duration) {
-                            setCurrentTime(mediaElement.currentTime + 0.001);
+                            playbackObserver.setCurrentTime(mediaElement.currentTime + 0.001);
                         }
                         else {
-                            setCurrentTime(position);
+                            playbackObserver.setCurrentTime(position);
                         }
                         return null;
                     case "encryption-data-encountered":
                         protectedSegments$.next(evt.value);
                         return null;
                     case "needs-buffer-flush":
-                        setCurrentTime(mediaElement.currentTime + 0.001);
+                        playbackObserver.setCurrentTime(mediaElement.currentTime + 0.001);
                         return null;
                 }
                 return evt;

package/dist/_esm5.processed/core/init/load_on_media_source.d.ts

@@ -15,30 +15,27 @@
  */
 import { Observable } from "rxjs";
 import Manifest from "../../manifest";
+import { IReadOnlySharedReference } from "../../utils/reference";
 import ABRManager from "../abr";
+import { PlaybackObserver } from "../api";
 import { SegmentFetcherCreator } from "../fetchers";
 import { IStreamOrchestratorOptions } from "../stream";
-import { IInitClockTick, IMediaSourceLoaderEvent } from "./types";
+import { IMediaSourceLoaderEvent } from "./types";
 /** Arguments needed by `createMediaSourceLoader`. */
 export interface IMediaSourceLoaderArguments {
     /** Module helping to choose the right Representation. */
     abrManager: ABRManager;
     /** Various stream-related options. */
     bufferOptions: IStreamOrchestratorOptions;
-    /** Observable emitting playback conditions regularly. */
-    clock$: Observable<IInitClockTick>;
     manifest: Manifest;
     /** Media Element on which the content will be played. */
     mediaElement: HTMLMediaElement;
+    /** Emit playback conditions regularly. */
+    playbackObserver: PlaybackObserver;
     /** Module to facilitate segment fetching. */
     segmentFetcherCreator: SegmentFetcherCreator;
-    /**
-     * Observable emitting the wanted playback rate as it changes.
-     * Replay the last value on subscription.
-     */
-    speed$: Observable<number>;
-    /** Perform an internal seek */
-    setCurrentTime: (nb: number) => void;
+    /** Last wanted playback rate. */
+    speed: IReadOnlySharedReference<number>;
 }
 /**
  * Returns a function allowing to load or reload the content in arguments into
@@ -46,4 +43,4 @@ export interface IMediaSourceLoaderArguments {
  * @param {Object} args
  * @returns {Function}
  */
-export default function createMediaSourceLoader({ mediaElement, manifest, clock$, speed$, bufferOptions, abrManager, segmentFetcherCreator, setCurrentTime }: IMediaSourceLoaderArguments): (mediaSource: MediaSource, initialTime: number, autoPlay: boolean) => Observable<IMediaSourceLoaderEvent>;
+export default function createMediaSourceLoader({ mediaElement, manifest, speed, bufferOptions, abrManager, playbackObserver, segmentFetcherCreator }: IMediaSourceLoaderArguments): (mediaSource: MediaSource, initialTime: number, autoPlay: boolean) => Observable<IMediaSourceLoaderEvent>;