rx-player 3.26.1 → 3.26.2

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

@@ -13,13 +13,12 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { EMPTY, merge as observableMerge, of as observableOf, Subject, throwError, } from "rxjs";
-import { filter, finalize, ignoreElements, mergeMap, switchMap, takeUntil, } from "rxjs/operators";
+import { EMPTY, filter, finalize, ignoreElements, merge as observableMerge, mergeMap, of as observableOf, Subject, switchMap, takeUntil, throwError, } from "rxjs";
 import { MediaError } from "../../errors";
 import log from "../../log";
 import SegmentBuffersStore from "../segment_buffers";
 import StreamOrchestrator from "../stream";
-import createStreamClock from "./create_stream_clock";
+import createStreamPlaybackObserver from "./create_stream_playback_observer";
 import DurationUpdater from "./duration_updater";
 import emitLoadedEvent from "./emit_loaded_event";
 import { maintainEndOfStream } from "./end_of_stream";
@@ -34,7 +33,7 @@ import updatePlaybackRate from "./update_playback_rate";
  * @returns {Function}
  */
 export default function createMediaSourceLoader(_a) {
-    var mediaElement = _a.mediaElement, manifest = _a.manifest, clock$ = _a.clock$, speed$ = _a.speed$, bufferOptions = _a.bufferOptions, abrManager = _a.abrManager, segmentFetcherCreator = _a.segmentFetcherCreator, setCurrentTime = _a.setCurrentTime;
+    var mediaElement = _a.mediaElement, manifest = _a.manifest, speed = _a.speed, bufferOptions = _a.bufferOptions, abrManager = _a.abrManager, playbackObserver = _a.playbackObserver, segmentFetcherCreator = _a.segmentFetcherCreator;
     /**
      * Load the content on the given MediaSource.
      * @param {MediaSource} mediaSource
@@ -50,14 +49,13 @@ export default function createMediaSourceLoader(_a) {
             var error_1 = new MediaError("MEDIA_STARTING_TIME_NOT_FOUND", "Wanted starting time not found in the Manifest.");
             return throwError(function () { return error_1; });
         }
-        /** Interface to create media buffers for loaded segments. */
+        /** Interface to create media buffers. */
         var segmentBuffersStore = new SegmentBuffersStore(mediaElement, mediaSource);
-        var _b = initialSeekAndPlay({ clock$: clock$, mediaElement: mediaElement, startTime: initialTime,
-            mustAutoPlay: autoPlay, setCurrentTime: setCurrentTime, isDirectfile: false }), seek$ = _b.seek$, play$ = _b.play$;
-        var playDone$ = play$.pipe(filter(function (evt) { return evt.type !== "warning"; }));
-        var streamEvents$ = playDone$.pipe(mergeMap(function () { return streamEventsEmitter(manifest, mediaElement, clock$); }));
-        var streamClock$ = createStreamClock(clock$, { autoPlay: autoPlay, initialPlay$: playDone$,
-            initialSeek$: seek$, manifest: manifest, speed$: speed$, startTime: initialTime });
+        var _b = initialSeekAndPlay({ mediaElement: mediaElement, playbackObserver: playbackObserver, startTime: initialTime,
+            mustAutoPlay: autoPlay }), seekAndPlay$ = _b.seekAndPlay$, initialPlayPerformed = _b.initialPlayPerformed, initialSeekPerformed = _b.initialSeekPerformed;
+        var observation$ = playbackObserver.observe(true);
+        var streamEvents$ = initialPlayPerformed.asObservable().pipe(filter(function (hasPlayed) { return hasPlayed; }), mergeMap(function () { return streamEventsEmitter(manifest, mediaElement, observation$); }));
+        var streamObserver = createStreamPlaybackObserver(manifest, playbackObserver, { autoPlay: autoPlay, initialPlayPerformed: initialPlayPerformed, initialSeekPerformed: initialSeekPerformed, speed: speed, startTime: initialTime });
         /** Cancel endOfStream calls when streams become active again. */
         var cancelEndOfStream$ = new Subject();
         /** Emits discontinuities detected by the StreamOrchestrator. */
@@ -65,7 +63,7 @@ export default function createMediaSourceLoader(_a) {
         /** Emits event when streams are "locked", meaning they cannot load segments. */
         var lockedStream$ = new Subject();
         // Creates Observable which will manage every Stream for the given Content.
-        var streams$ = StreamOrchestrator({ manifest: manifest, initialPeriod: initialPeriod }, streamClock$, abrManager, segmentBuffersStore, segmentFetcherCreator, bufferOptions).pipe(mergeMap(function (evt) {
+        var streams$ = StreamOrchestrator({ manifest: manifest, initialPeriod: initialPeriod }, streamObserver, abrManager, segmentBuffersStore, segmentFetcherCreator, bufferOptions).pipe(mergeMap(function (evt) {
             switch (evt.type) {
                 case "end-of-stream":
                     log.debug("Init: end-of-stream order received.");
@@ -90,23 +88,22 @@ export default function createMediaSourceLoader(_a) {
          * the user on the media element and force a speed of `0` when the buffer is
          * empty, so it can build back buffer.
          */
-        var playbackRate$ = updatePlaybackRate(mediaElement, speed$, clock$)
+        var playbackRate$ = updatePlaybackRate(mediaElement, speed, observation$)
             .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, manifest, discontinuityUpdate$, lockedStream$, setCurrentTime);
+        var stallAvoider$ = StallAvoider(playbackObserver, manifest, lockedStream$, discontinuityUpdate$);
         /**
          * Emit a "loaded" events once the initial play has been performed and the
          * media can begin playback.
          * Also emits warning events if issues arise when doing so.
          */
-        var loadingEvts$ = play$.pipe(switchMap(function (evt) {
-            if (evt.type === "warning") {
-                return observableOf(evt);
-            }
-            return emitLoadedEvent(clock$, mediaElement, segmentBuffersStore, false);
+        var loadingEvts$ = seekAndPlay$.pipe(switchMap(function (evt) {
+            return evt.type === "warning" ?
+                observableOf(evt) :
+                emitLoadedEvent(observation$, mediaElement, segmentBuffersStore, false);
         }));
         return observableMerge(durationUpdater$, loadingEvts$, playbackRate$, stallAvoider$, streams$, streamEvents$).pipe(finalize(function () {
             // clean-up every created SegmentBuffers

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

@@ -13,8 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { defer as observableDefer, EMPTY, from as observableFrom, merge as observableMerge, of as observableOf, timer as observableTimer, } from "rxjs";
-import { mapTo, mergeMap, mergeMapTo, share, take, } from "rxjs/operators";
+import { defer as observableDefer, EMPTY, from as observableFrom, map, merge as observableMerge, mergeMap, of as observableOf, share, take, timer as observableTimer, } from "rxjs";
 import config from "../../config";
 import log from "../../log";
 import throttle from "../../utils/rx-throttle";
@@ -81,13 +80,15 @@ export default function manifestUpdateScheduler(_a) {
             var completeRefresh = _a.completeRefresh, delay = _a.delay, canUseUnsafeMode = _a.canUseUnsafeMode;
             var unsafeMode = canUseUnsafeMode && unsafeModeEnabled;
             return startManualRefreshTimer(delay !== null && delay !== void 0 ? delay : 0, minimumManifestUpdateInterval, sendingTime)
-                .pipe(mapTo({ completeRefresh: completeRefresh, unsafeMode: unsafeMode }));
+                .pipe(map(function () { return ({ completeRefresh: completeRefresh, unsafeMode: unsafeMode }); }));
         }));
         /** Emit when the Manifest tells us that it has "expired". */
         var expired$ = manifest.expired === null ?
             EMPTY :
-            observableTimer(minInterval)
-                .pipe(mergeMapTo(observableFrom(manifest.expired)), mapTo({ completeRefresh: true, unsafeMode: unsafeModeEnabled }));
+            observableTimer(minInterval).pipe(mergeMap(function () {
+                return manifest.expired === null ? EMPTY :
+                    observableFrom(manifest.expired);
+            }), map(function () { return ({ completeRefresh: true, unsafeMode: unsafeModeEnabled }); }));
         /** Emit when the Manifest should normally be refreshed. */
         var autoRefresh$ = createAutoRefreshObservable();
         return observableMerge(autoRefresh$, internalRefresh$, expired$).pipe(take(1), mergeMap(function (_a) {
@@ -149,7 +150,7 @@ export default function manifestUpdateScheduler(_a) {
                 actualRefreshInterval = regularRefreshDelay;
             }
             return observableTimer(Math.max(actualRefreshInterval, minInterval))
-                .pipe(mapTo({ completeRefresh: false, unsafeMode: unsafeModeEnabled }));
+                .pipe(map(function () { return ({ completeRefresh: false, unsafeMode: unsafeModeEnabled }); }));
         }
     }
     /**
@@ -192,7 +193,7 @@ export default function manifestUpdateScheduler(_a) {
                 catch (e) {
                     var message = e instanceof Error ? e.message :
                         "unknown error";
-                    log.warn("MUS: Attempt to update Manifest failed: " + message, "Re-downloading the Manifest fully");
+                    log.warn("MUS: Attempt to update Manifest failed: ".concat(message), "Re-downloading the Manifest fully");
                     return startManualRefreshTimer(FAILED_PARTIAL_UPDATE_MANIFEST_REFRESH_DELAY, minimumManifestUpdateInterval, newSendingTime)
                         .pipe(mergeMap(function () {
                         return refreshManifest({ completeRefresh: true, unsafeMode: false });

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

@@ -15,8 +15,9 @@
  */
 import { Observable } from "rxjs";
 import Manifest, { Period } from "../../manifest";
+import { PlaybackObserver } from "../api";
 import { IBufferType } from "../segment_buffers";
-import { IInitClockTick, IStalledEvent, IUnstalledEvent, IWarningEvent } from "./types";
+import { IStalledEvent, IUnstalledEvent, IWarningEvent } from "./types";
 export interface ILockedStreamEvent {
     /** Buffer type for which no segment will currently load. */
     bufferType: IBufferType;
@@ -64,14 +65,11 @@ export interface IDiscontinuityTimeInfo {
  * Monitor situations where playback is stalled and try to get out of those.
  * Emit "stalled" then "unstalled" respectively when an unavoidable stall is
  * encountered and exited.
- * @param {Observable} clock$ - Observable emitting the current playback
- * conditions.
- * @param {HTMLMediaElement} mediaElement - The HTMLMediaElement on which the
- * media is played.
+ * @param {object} playbackObserver - emit the current playback conditions.
  * @param {Object} manifest - The Manifest of the currently-played content.
  * @param {Observable} discontinuityUpdate$ - Observable emitting encountered
  * discontinuities for loaded Period and buffer types.
  * @param {Function} setCurrentTime
  * @returns {Observable}
  */
-export default function StallAvoider(clock$: Observable<IInitClockTick>, mediaElement: HTMLMediaElement, manifest: Manifest | null, discontinuityUpdate$: Observable<IDiscontinuityEvent>, lockedStream$: Observable<ILockedStreamEvent>, setCurrentTime: (nb: number) => void): Observable<IStalledEvent | IUnstalledEvent | IWarningEvent>;
+export default function StallAvoider(playbackObserver: PlaybackObserver, manifest: Manifest | null, lockedStream$: Observable<ILockedStreamEvent>, discontinuityUpdate$: Observable<IDiscontinuityEvent>): Observable<IStalledEvent | IUnstalledEvent | IWarningEvent>;

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

@@ -13,8 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { merge as observableMerge, } from "rxjs";
-import { ignoreElements, map, scan, tap, withLatestFrom, } from "rxjs/operators";
+import { ignoreElements, map, merge as observableMerge, scan, tap, withLatestFrom, } from "rxjs";
 import isSeekingApproximate from "../../compat/is_seeking_approximate";
 import config from "../../config";
 import { MediaError } from "../../errors";
@@ -31,26 +30,22 @@ var EPSILON = 1 / 60;
  * Monitor situations where playback is stalled and try to get out of those.
  * Emit "stalled" then "unstalled" respectively when an unavoidable stall is
  * encountered and exited.
- * @param {Observable} clock$ - Observable emitting the current playback
- * conditions.
- * @param {HTMLMediaElement} mediaElement - The HTMLMediaElement on which the
- * media is played.
+ * @param {object} playbackObserver - emit the current playback conditions.
  * @param {Object} manifest - The Manifest of the currently-played content.
  * @param {Observable} discontinuityUpdate$ - Observable emitting encountered
  * discontinuities for loaded Period and buffer types.
  * @param {Function} setCurrentTime
  * @returns {Observable}
  */
-export default function StallAvoider(clock$, mediaElement, manifest, discontinuityUpdate$, lockedStream$, setCurrentTime) {
+export default function StallAvoider(playbackObserver, manifest, lockedStream$, discontinuityUpdate$) {
     var initialDiscontinuitiesStore = [];
     /**
      * Emit every known audio and video buffer discontinuities in chronological
      * order (first ordered by Period's start, then by bufferType in any order.
      */
-    var discontinuitiesStore$ = discontinuityUpdate$.pipe(withLatestFrom(clock$), // listen to clock to clean-up old discontinuities
-    scan(function (discontinuitiesStore, _a) {
-        var evt = _a[0], tick = _a[1];
-        return updateDiscontinuitiesStore(discontinuitiesStore, evt, tick);
+    var discontinuitiesStore$ = discontinuityUpdate$.pipe(withLatestFrom(playbackObserver.observe(true)), scan(function (discontinuitiesStore, _a) {
+        var evt = _a[0], observation = _a[1];
+        return updateDiscontinuitiesStore(discontinuitiesStore, evt, observation);
     }, initialDiscontinuitiesStore));
     /**
      * On some devices (right now only seen on Tizen), seeking through the
@@ -82,29 +77,35 @@ export default function StallAvoider(clock$, mediaElement, manifest, discontinui
      * If we're rebuffering waiting on data of a "locked stream", seek into the
      * Period handled by that stream to unlock the situation.
      */
-    var unlock$ = lockedStream$.pipe(withLatestFrom(clock$), tap(function (_a) {
+    var unlock$ = lockedStream$.pipe(withLatestFrom(playbackObserver.observe(true)), tap(function (_a) {
         var _b;
-        var lockedStreamEvt = _a[0], tick = _a[1];
+        var lockedStreamEvt = _a[0], observation = _a[1];
         // TODO(PaulB) also skip when the user's wanted speed is set to `0`, as we
         // might not want to seek in that case?
-        if (!tick.rebuffering ||
-            tick.paused || (lockedStreamEvt.bufferType !== "audio" &&
+        if (!observation.rebuffering ||
+            observation.paused || (lockedStreamEvt.bufferType !== "audio" &&
             lockedStreamEvt.bufferType !== "video")) {
             return;
         }
-        var currPos = tick.position;
-        var rebufferingPos = (_b = tick.rebuffering.position) !== null && _b !== void 0 ? _b : currPos;
+        var currPos = observation.position;
+        var rebufferingPos = (_b = observation.rebuffering.position) !== null && _b !== void 0 ? _b : currPos;
         var lockedPeriodStart = lockedStreamEvt.period.start;
         if (currPos < lockedPeriodStart &&
             Math.abs(rebufferingPos - lockedPeriodStart) < 1) {
             log.warn("Init: rebuffering because of a future locked stream.\n" +
                 "Trying to unlock by seeking to the next Period");
-            setCurrentTime(lockedPeriodStart + 0.001);
+            playbackObserver.setCurrentTime(lockedPeriodStart + 0.001);
         }
-    }), ignoreElements());
-    var stall$ = clock$.pipe(withLatestFrom(discontinuitiesStore$), map(function (_a) {
-        var tick = _a[0], discontinuitiesStore = _a[1];
-        var buffered = tick.buffered, position = tick.position, readyState = tick.readyState, rebuffering = tick.rebuffering, freezing = tick.freezing;
+    }), 
+    // 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());
+    var stall$ = playbackObserver.observe(true).pipe(withLatestFrom(discontinuitiesStore$), map(function (_a) {
+        var observation = _a[0], discontinuitiesStore = _a[1];
+        var buffered = observation.buffered, position = observation.position, readyState = observation.readyState, rebuffering = observation.rebuffering, freezing = observation.freezing;
         if (freezing !== null) {
             var now = performance.now();
             var referenceTimestamp = prevFreezingState === null ?
@@ -112,7 +113,7 @@ export default function StallAvoider(clock$, mediaElement, manifest, discontinui
                 prevFreezingState.attemptTimestamp;
             if (now - referenceTimestamp > UNFREEZING_SEEK_DELAY) {
                 log.warn("Init: trying to seek to un-freeze player");
-                setCurrentTime(tick.getCurrentTime() + UNFREEZING_DELTA_POSITION);
+                playbackObserver.setCurrentTime(playbackObserver.getCurrentTime() + UNFREEZING_DELTA_POSITION);
                 prevFreezingState = { attemptTimestamp: now };
             }
             if (now - freezing.timestamp > FREEZING_STALLED_DELAY) {
@@ -125,16 +126,29 @@ export default function StallAvoider(clock$, mediaElement, manifest, discontinui
         }
         if (rebuffering === null) {
             if (readyState === 1) {
-                // With a readyState set to 1, we should still be not able to play,
-                // anounce that we're stalled due to an unknown "freezing" status.
+                // With a readyState set to 1, we should still not be able to play:
+                // Return that we're stalled
+                var reason = void 0;
+                if (observation.seeking) {
+                    reason = observation.internalSeeking ? "internal-seek" :
+                        "seeking";
+                }
+                else {
+                    reason = "not-ready";
+                }
                 return { type: "stalled",
-                    value: "freezing" };
+                    value: reason };
             }
             return { type: "unstalled",
                 value: null };
         }
-        if (tick.seeking) {
-            lastSeekingPosition = tick.position;
+        // We want to separate a stall situation when a seek is due to a seek done
+        // internally by the player to when its due to a regular user seek.
+        var stalledReason = rebuffering.reason === "seeking" &&
+            observation.internalSeeking ? "internal-seek" :
+            rebuffering.reason;
+        if (observation.seeking) {
+            lastSeekingPosition = observation.position;
         }
         else if (lastSeekingPosition !== null) {
             var now = performance.now();
@@ -142,17 +156,17 @@ export default function StallAvoider(clock$, mediaElement, manifest, discontinui
                 ignoredStallTimeStamp = now;
             }
             if (isSeekingApproximate &&
-                tick.position < lastSeekingPosition &&
+                observation.position < lastSeekingPosition &&
                 now - ignoredStallTimeStamp < FORCE_DISCONTINUITY_SEEK_DELAY) {
                 return { type: "stalled",
-                    value: rebuffering.reason };
+                    value: stalledReason };
             }
             lastSeekingPosition = null;
         }
         ignoredStallTimeStamp = null;
         if (manifest === null) {
             return { type: "stalled",
-                value: rebuffering.reason };
+                value: stalledReason };
         }
         /** Position at which data is awaited. */
         var stalledPosition = rebuffering.position;
@@ -160,12 +174,12 @@ export default function StallAvoider(clock$, mediaElement, manifest, discontinui
             var skippableDiscontinuity = findSeekableDiscontinuity(discontinuitiesStore, manifest, stalledPosition);
             if (skippableDiscontinuity !== null) {
                 var realSeekTime = skippableDiscontinuity + 0.001;
-                if (realSeekTime <= mediaElement.currentTime) {
-                    log.info("Init: position to seek already reached, no seeking", mediaElement.currentTime, realSeekTime);
+                if (realSeekTime <= playbackObserver.getCurrentTime()) {
+                    log.info("Init: position to seek already reached, no seeking", playbackObserver.getCurrentTime(), realSeekTime);
                 }
                 else {
                     log.warn("SA: skippable discontinuity found in the stream", position, realSeekTime);
-                    setCurrentTime(realSeekTime);
+                    playbackObserver.setCurrentTime(realSeekTime);
                     return EVENTS.warning(generateDiscontinuityError(stalledPosition, realSeekTime));
                 }
             }
@@ -181,9 +195,9 @@ export default function StallAvoider(clock$, mediaElement, manifest, discontinui
         var nextBufferRangeGap = getNextRangeGap(buffered, freezePosition);
         if (nextBufferRangeGap < BUFFER_DISCONTINUITY_THRESHOLD) {
             var seekTo = (freezePosition + nextBufferRangeGap + EPSILON);
-            if (mediaElement.currentTime < seekTo) {
+            if (playbackObserver.getCurrentTime() < seekTo) {
                 log.warn("Init: discontinuity encountered inferior to the threshold", freezePosition, seekTo, BUFFER_DISCONTINUITY_THRESHOLD);
-                setCurrentTime(seekTo);
+                playbackObserver.setCurrentTime(seekTo);
                 return EVENTS.warning(generateDiscontinuityError(freezePosition, seekTo));
             }
         }
@@ -193,16 +207,16 @@ export default function StallAvoider(clock$, mediaElement, manifest, discontinui
             var period = manifest.periods[i];
             if (period.end !== undefined && period.end <= freezePosition) {
                 if (manifest.periods[i + 1].start > freezePosition &&
-                    manifest.periods[i + 1].start > mediaElement.currentTime) {
+                    manifest.periods[i + 1].start > playbackObserver.getCurrentTime()) {
                     var nextPeriod = manifest.periods[i + 1];
-                    setCurrentTime(nextPeriod.start);
+                    playbackObserver.setCurrentTime(nextPeriod.start);
                     return EVENTS.warning(generateDiscontinuityError(freezePosition, nextPeriod.start));
                 }
                 break;
             }
         }
         return { type: "stalled",
-            value: rebuffering.reason };
+            value: stalledReason };
     }));
     return observableMerge(unlock$, stall$);
 }
@@ -272,14 +286,14 @@ function eventContainsDiscontinuity(evt) {
  *     store it in Period's chronological order in the Array.
  * @param {Array.<Object>} discontinuitiesStore
  * @param {Object} evt
- * @param {Object} tick
+ * @param {Object} observation
  * @returns {Array.<Object>}
  */
-function updateDiscontinuitiesStore(discontinuitiesStore, evt, tick) {
+function updateDiscontinuitiesStore(discontinuitiesStore, evt, observation) {
     // First, perform clean-up of old discontinuities
     while (discontinuitiesStore.length > 0 &&
         discontinuitiesStore[0].period.end !== undefined &&
-        discontinuitiesStore[0].period.end + 10 < tick.position) {
+        discontinuitiesStore[0].period.end + 10 < observation.position) {
         discontinuitiesStore.shift();
     }
     var period = evt.period, bufferType = evt.bufferType;

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

@@ -15,7 +15,7 @@
  */
 import { Observable } from "rxjs";
 import Manifest from "../../../manifest";
-import { IInitClockTick } from "../types";
+import { IPlaybackObservation } from "../../api";
 import { IStreamEvent } from "./types";
 /**
  * Get events from manifest and emit each time an event has to be emitted
@@ -23,5 +23,5 @@ import { IStreamEvent } from "./types";
  * @param {HTMLMediaElement} mediaElement
  * @returns {Observable}
  */
-declare function streamEventsEmitter(manifest: Manifest, mediaElement: HTMLMediaElement, clock$: Observable<IInitClockTick>): Observable<IStreamEvent>;
+declare function streamEventsEmitter(manifest: Manifest, mediaElement: HTMLMediaElement, observation$: Observable<IPlaybackObservation>): Observable<IStreamEvent>;
 export default streamEventsEmitter;

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

@@ -13,8 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { combineLatest as observableCombineLatest, concat as observableConcat, EMPTY, interval, of as observableOf, } from "rxjs";
-import { distinctUntilChanged, ignoreElements, map, mergeMap, pairwise, scan, startWith, switchMap, tap, } from "rxjs/operators";
+import { combineLatest as observableCombineLatest, concat as observableConcat, distinctUntilChanged, EMPTY, ignoreElements, interval, map, mergeMap, pairwise, scan, startWith, switchMap, tap, of as observableOf, } from "rxjs";
 import config from "../../../config";
 import { fromEvent } from "../../../utils/event_emitter";
 import refreshScheduledEventsList from "./refresh_scheduled_events_list";
@@ -33,23 +32,23 @@ function isFiniteStreamEvent(evt) {
  * @param {HTMLMediaElement} mediaElement
  * @returns {Observable}
  */
-function streamEventsEmitter(manifest, mediaElement, clock$) {
+function streamEventsEmitter(manifest, mediaElement, observation$) {
     var eventsBeingPlayed = new WeakMap();
     var lastScheduledEvents = [];
     var scheduledEvents$ = fromEvent(manifest, "manifestUpdate").pipe(startWith(null), scan(function (oldScheduledEvents) {
         return refreshScheduledEventsList(oldScheduledEvents, manifest);
     }, []));
     /**
-     * Examine playback situation from clock ticks to emit stream events and
+     * Examine playback situation from playback observations to emit stream events and
      * prepare set onExit callbacks if needed.
      * @param {Array.<Object>} scheduledEvents
-     * @param {Object} oldTick
-     * @param {Object} newTick
+     * @param {Object} oldObservation
+     * @param {Object} newObservation
      * @returns {Observable}
      */
-    function emitStreamEvents$(scheduledEvents, oldClockTick, newClockTick) {
-        var previousTime = oldClockTick.currentTime;
-        var isSeeking = newClockTick.isSeeking, currentTime = newClockTick.currentTime;
+    function emitStreamEvents$(scheduledEvents, oldObservation, newObservation) {
+        var previousTime = oldObservation.currentTime;
+        var isSeeking = newObservation.isSeeking, currentTime = newObservation.currentTime;
         var eventsToSend = [];
         var eventsToExit = [];
         for (var i = 0; i < scheduledEvents.length; i++) {
@@ -94,7 +93,13 @@ function streamEventsEmitter(manifest, mediaElement, clock$) {
             if (typeof evt.onExit === "function") {
                 evt.onExit();
             }
-        }), ignoreElements()) : EMPTY);
+        }), 
+        // 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()) : EMPTY);
     }
     /**
      * This pipe allows to control wether the polling should occur, if there
@@ -106,15 +111,15 @@ function streamEventsEmitter(manifest, mediaElement, clock$) {
         }
         return observableCombineLatest([
             interval(STREAM_EVENT_EMITTER_POLL_INTERVAL).pipe(startWith(null)),
-            clock$,
+            observation$,
         ]).pipe(map(function (_a) {
-            var _ = _a[0], clockTick = _a[1];
-            var seeking = clockTick.seeking;
+            var _ = _a[0], observation = _a[1];
+            var seeking = observation.seeking;
             return { isSeeking: seeking,
                 currentTime: mediaElement.currentTime };
         }), pairwise(), mergeMap(function (_a) {
-            var oldTick = _a[0], newTick = _a[1];
-            return emitStreamEvents$(lastScheduledEvents, oldTick, newTick);
+            var oldObservation = _a[0], newObservation = _a[1];
+            return emitStreamEvents$(lastScheduledEvents, oldObservation, newObservation);
         }));
     }));
 }

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

@@ -13,8 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { fromEvent as observableFromEvent, } from "rxjs";
-import { mergeMap } from "rxjs/operators";
+import { fromEvent as observableFromEvent, mergeMap, } from "rxjs";
 import { MediaError } from "../../errors";
 /**
  * Returns an observable which throws the right MediaError as soon an "error"

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

@@ -15,31 +15,11 @@
  */
 import { ICustomError } from "../../errors";
 import Manifest, { Adaptation, Period, Representation } from "../../manifest";
-import { IClockMediaEventType, IFreezingStatus, IRebufferingStatus } from "../api";
 import { IAttachedMediaKeysEvent, IBlacklistProtectionDataEvent, ICreatedMediaKeysEvent, IEncryptedEvent, IInitDataIgnoredEvent, IKeysUpdateEvent, INoUpdateEvent, ISessionMessageEvent, ISessionUpdatedEvent } from "../eme";
 import SegmentBuffersStore from "../segment_buffers";
 import { IActivePeriodChangedEvent, IAdaptationChangeEvent, IBitrateEstimationChangeEvent, ICompletedStreamEvent, IEncryptionDataEncounteredEvent, IInbandEventsEvent, INeedsBufferFlushEvent, INeedsDecipherabilityFlush, INeedsMediaSourceReload, IPeriodStreamClearedEvent, IPeriodStreamReadyEvent, IRepresentationChangeEvent, IStreamEventAddedSegment, IStreamManifestMightBeOutOfSync, IStreamNeedsManifestRefresh } from "../stream";
 import { IEMEDisabledEvent } from "./create_eme_manager";
 import { IStreamEventEvent, IStreamEventSkipEvent } from "./stream_events_emitter";
-/** Object awaited by the `Init` on each clock tick. */
-export interface IInitClockTick {
-    position: number;
-    getCurrentTime: () => number;
-    buffered: TimeRanges;
-    duration: number;
-    bufferGap: number;
-    event: IClockMediaEventType;
-    playbackRate: number;
-    currentRange: {
-        start: number;
-        end: number;
-    } | null;
-    readyState: number;
-    paused: boolean;
-    rebuffering: IRebufferingStatus | null;
-    freezing: IFreezingStatus | null;
-    seeking: boolean;
-}
 /** Event sent after the Manifest has been loaded and parsed for the first time. */
 export interface IManifestReadyEvent {
     type: "manifestReady";

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

@@ -14,7 +14,8 @@
  * limitations under the License.
  */
 import { Observable } from "rxjs";
-import { IInitClockTick } from "./types";
+import { IReadOnlySharedReference } from "../../utils/reference";
+import { IPlaybackObservation } from "../api";
 export interface IPlaybackRateOptions {
     pauseWhenRebuffering?: boolean;
 }
@@ -24,8 +25,8 @@ export interface IPlaybackRateOptions {
  * rebuffering and restore the speed once it appears to exit rebuffering status.
  *
  * @param {HTMLMediaElement} mediaElement
- * @param {Observable} speed$ - emit speed set by the user
- * @param {Observable} clock$ - Current playback conditions
+ * @param {Observable} speed - last speed set by the user
+ * @param {Observable} observation$ - Current playback conditions
  * @returns {Observable}
  */
-export default function updatePlaybackRate(mediaElement: HTMLMediaElement, speed$: Observable<number>, clock$: Observable<IInitClockTick>): Observable<number>;
+export default function updatePlaybackRate(mediaElement: HTMLMediaElement, speed: IReadOnlySharedReference<number>, observation$: Observable<IPlaybackObservation>): Observable<number>;

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

@@ -13,8 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { defer as observableDefer, of as observableOf, } from "rxjs";
-import { distinctUntilChanged, map, startWith, switchMap, tap, } from "rxjs/operators";
+import { defer as observableDefer, distinctUntilChanged, map, of as observableOf, startWith, switchMap, tap, } from "rxjs";
 import log from "../../log";
 /**
  * Manage playback speed.
@@ -22,13 +21,13 @@ import log from "../../log";
  * rebuffering and restore the speed once it appears to exit rebuffering status.
  *
  * @param {HTMLMediaElement} mediaElement
- * @param {Observable} speed$ - emit speed set by the user
- * @param {Observable} clock$ - Current playback conditions
+ * @param {Observable} speed - last speed set by the user
+ * @param {Observable} observation$ - Current playback conditions
  * @returns {Observable}
  */
-export default function updatePlaybackRate(mediaElement, speed$, clock$) {
-    var forcePause$ = clock$
-        .pipe(map(function (timing) { return timing.rebuffering !== null; }), startWith(false), distinctUntilChanged());
+export default function updatePlaybackRate(mediaElement, speed, observation$) {
+    var forcePause$ = observation$
+        .pipe(map(function (observation) { return observation.rebuffering !== null; }), startWith(false), distinctUntilChanged());
     return forcePause$
         .pipe(switchMap(function (shouldForcePause) {
         if (shouldForcePause) {
@@ -38,10 +37,10 @@ export default function updatePlaybackRate(mediaElement, speed$, clock$) {
                 return observableOf(0);
             });
         }
-        return speed$
-            .pipe(tap(function (speed) {
-            log.info("Init: Resume playback speed", speed);
-            mediaElement.playbackRate = speed;
+        return speed.asObservable()
+            .pipe(tap(function (lastSpeed) {
+            log.info("Init: Resume playback speed", lastSpeed);
+            mediaElement.playbackRate = lastSpeed;
         }));
     }));
 }

package/dist/_esm5.processed/core/segment_buffers/garbage_collector.d.ts

@@ -19,7 +19,7 @@ export interface IGarbageCollectorArgument {
     /** SegmentBuffer implementation */
     segmentBuffer: SegmentBuffer;
     /** Emit current position in seconds regularly */
-    clock$: Observable<number>;
+    currentTime$: Observable<number>;
     /** Maximum time to keep behind current time position, in seconds */
     maxBufferBehind$: Observable<number>;
     /** Minimum time to keep behind current time position, in seconds */
@@ -27,10 +27,10 @@ export interface IGarbageCollectorArgument {
 }
 /**
  * Perform cleaning of the buffer according to the values set by the user
- * at each clock tick and each times the maxBufferBehind/maxBufferAhead values
- * change.
+ * each time `currentTime$` emits and each times the
+ * maxBufferBehind/maxBufferAhead values change.
  *
  * @param {Object} opt
  * @returns {Observable}
  */
-export default function BufferGarbageCollector({ segmentBuffer, clock$, maxBufferBehind$, maxBufferAhead$, }: IGarbageCollectorArgument): Observable<never>;
+export default function BufferGarbageCollector({ segmentBuffer, currentTime$, maxBufferBehind$, maxBufferAhead$, }: IGarbageCollectorArgument): Observable<never>;