rx-player 4.0.0-beta.0 → 4.0.0-beta.2

package/dist/_esm5.processed/core/fetchers/segment/task_prioritizer.js

@@ -1,5 +1,6 @@
 import log from "../../../log";
 import arrayFindIndex from "../../../utils/array_find_index";
+import createCancellablePromise from "../../../utils/create_cancellable_promise";
 import TaskCanceller, { CancellationError, } from "../../../utils/task_canceller";
 var TaskPrioritizer = /** @class */ (function () {
     /**
@@ -41,18 +42,31 @@ var TaskPrioritizer = /** @class */ (function () {
     TaskPrioritizer.prototype.create = function (taskFn, priority, callbacks, cancelSignal) {
         var _this = this;
         var newTask;
-        return new Promise(function (resolve, reject) {
+        return createCancellablePromise(cancelSignal, function (resolve, reject) {
             /** Function allowing to start the underlying Promise. */
             var trigger = function () {
                 if (newTask.hasEnded) {
-                    unregisterCancelSignal();
                     return;
                 }
-                var interrupter = new TaskCanceller({ cancelOn: cancelSignal });
+                var finishTask = function () {
+                    unlinkInterrupter();
+                    _this._endTask(newTask);
+                };
+                var onResolve = function (value) {
+                    callbacks.beforeEnded();
+                    finishTask();
+                    resolve(value);
+                };
+                var onReject = function (err) {
+                    finishTask();
+                    reject(err);
+                };
+                var interrupter = new TaskCanceller();
+                var unlinkInterrupter = interrupter.linkToSignal(cancelSignal);
                 newTask.interrupter = interrupter;
                 interrupter.signal.register(function () {
                     newTask.interrupter = null;
-                    if (!cancelSignal.isCancelled) {
+                    if (!cancelSignal.isCancelled()) {
                         callbacks.beforeInterrupted();
                     }
                 });
@@ -63,31 +77,14 @@ var TaskPrioritizer = /** @class */ (function () {
                 newTask.taskFn(interrupter.signal)
                     .then(onResolve)
                     .catch(function (err) {
-                    if (!cancelSignal.isCancelled &&
-                        interrupter.isUsed &&
+                    if (!cancelSignal.isCancelled() &&
+                        interrupter.isUsed() &&
                         err instanceof CancellationError) {
                         return;
                     }
                     onReject(err);
                 });
             };
-            var unregisterCancelSignal = cancelSignal.register(function (cancellationError) {
-                _this._endTask(newTask);
-                reject(cancellationError);
-            });
-            var finishTask = function () {
-                unregisterCancelSignal();
-                _this._endTask(newTask);
-            };
-            var onResolve = function (value) {
-                callbacks.beforeEnded();
-                finishTask();
-                resolve(value);
-            };
-            var onReject = function (err) {
-                finishTask();
-                reject(err);
-            };
             newTask = {
                 hasEnded: false,
                 priority: priority,
@@ -112,6 +109,7 @@ var TaskPrioritizer = /** @class */ (function () {
                     _this._interruptCancellableTasks();
                 }
             }
+            return function () { return _this._endTask(newTask); };
         });
     };
     TaskPrioritizer.prototype._endTask = function (task) {

package/dist/_esm5.processed/core/fetchers/utils/schedule_request.js

@@ -251,14 +251,14 @@ export function scheduleRequestWithCdns(cdns, cdnPrioritizer, performRequest, op
                 var nextCdn;
                 return __generator(this, function (_a) {
                     nextCdn = getCdnToRequest();
-                    if (cancellationSignal.isCancelled) {
+                    if (cancellationSignal.isCancelled()) {
                         throw cancellationSignal.cancellationError;
                     }
                     if (nextCdn === undefined) {
                         throw prevRequestError;
                     }
                     onRetry(prevRequestError);
-                    if (cancellationSignal.isCancelled) {
+                    if (cancellationSignal.isCancelled()) {
                         throw cancellationSignal.cancellationError;
                     }
                     return [2 /*return*/, waitPotentialBackoffAndRequest(nextCdn, prevRequestError)];
@@ -286,25 +286,35 @@ export function scheduleRequestWithCdns(cdns, cdnPrioritizer, performRequest, op
             if (blockedFor <= 0) {
                 return requestCdn(nextWantedCdn);
             }
-            var canceller = new TaskCanceller({ cancelOn: cancellationSignal });
+            var canceller = new TaskCanceller();
+            var unlinkCanceller = canceller.linkToSignal(cancellationSignal);
             return new Promise(function (res, rej) {
                 /* eslint-disable-next-line @typescript-eslint/no-misused-promises */
                 cdnPrioritizer === null || cdnPrioritizer === void 0 ? void 0 : cdnPrioritizer.addEventListener("priorityChange", function () {
                     var updatedPrioritaryCdn = getCdnToRequest();
-                    if (cancellationSignal.isCancelled) {
+                    if (cancellationSignal.isCancelled()) {
                         throw cancellationSignal.cancellationError;
                     }
                     if (updatedPrioritaryCdn === undefined) {
-                        return rej(prevRequestError);
+                        return cleanAndReject(prevRequestError);
                     }
                     if (updatedPrioritaryCdn !== nextWantedCdn) {
                         canceller.cancel();
                         waitPotentialBackoffAndRequest(updatedPrioritaryCdn, prevRequestError)
-                            .then(res, rej);
+                            .then(cleanAndResolve, cleanAndReject);
                     }
                 }, canceller.signal);
                 cancellableSleep(blockedFor, canceller.signal)
-                    .then(function () { return requestCdn(nextWantedCdn).then(res, rej); }, noop);
+                    .then(function () { return requestCdn(nextWantedCdn)
+                    .then(cleanAndResolve, cleanAndReject); }, noop);
+                function cleanAndResolve(response) {
+                    unlinkCanceller();
+                    res(response);
+                }
+                function cleanAndReject(err) {
+                    unlinkCanceller();
+                    rej(err);
+                }
             });
         }
         /**

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

@@ -73,7 +73,7 @@ var DirectFileContentInitializer = /** @class */ (function (_super) {
          * Class trying to avoid various stalling situations, emitting "stalled"
          * events when it cannot, as well as "unstalled" events when it get out of one.
          */
-        var rebufferingController = new RebufferingController(playbackObserver, null, speed);
+        var rebufferingController = new RebufferingController(playbackObserver, null, null, speed);
         rebufferingController.addEventListener("stalled", function (evt) {
             return _this.trigger("stalled", evt);
         });
@@ -145,7 +145,7 @@ var DirectFileContentInitializer = /** @class */ (function (_super) {
             }, { emitCurrentValue: true, clearSignal: cancelSignal });
         })
             .catch(function (err) {
-            if (!cancelSignal.isCancelled) {
+            if (!cancelSignal.isCancelled()) {
                 _this._onFatalError(err);
             }
         });

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

@@ -69,6 +69,7 @@ import config from "../../config";
 import { MediaError } from "../../errors";
 import log from "../../log";
 import assert from "../../utils/assert";
+import createCancellablePromise from "../../utils/create_cancellable_promise";
 import objectAssign from "../../utils/object_assign";
 import createSharedReference from "../../utils/reference";
 import TaskCanceller from "../../utils/task_canceller";
@@ -86,7 +87,7 @@ import getInitialTime from "./utils/get_initial_time";
 import getLoadedReference from "./utils/get_loaded_reference";
 import performInitialSeekAndPlay from "./utils/initial_seek_and_play";
 import initializeContentDecryption from "./utils/initialize_content_decryption";
-import MediaDurationUpdater from "./utils/media_duration_updater";
+import MediaSourceDurationUpdater from "./utils/media_source_duration_updater";
 import RebufferingController from "./utils/rebuffering_controller";
 import streamEventsEmitter from "./utils/stream_events_emitter";
 import listenToMediaError from "./utils/throw_on_media_error";
@@ -127,11 +128,7 @@ var MediaSourceContentInitializer = /** @class */ (function (_super) {
         if (this._initialManifestProm !== null) {
             return;
         }
-        this._initialManifestProm = new Promise(function (res, rej) {
-            _this._initCanceller.signal.register(function (err) {
-                _this._manifestFetcher.dispose();
-                rej(err);
-            });
+        this._initialManifestProm = createCancellablePromise(this._initCanceller.signal, function (res, rej) {
             _this._manifestFetcher.addEventListener("warning", function (err) {
                 return _this.trigger("warning", err);
             });
@@ -142,7 +139,10 @@ var MediaSourceContentInitializer = /** @class */ (function (_super) {
             _this._manifestFetcher.addEventListener("manifestReady", function (manifest) {
                 res(manifest);
             });
-            _this._manifestFetcher.start();
+        });
+        this._manifestFetcher.start();
+        this._initCanceller.signal.register(function () {
+            _this._manifestFetcher.dispose();
         });
     };
     /**
@@ -176,7 +176,7 @@ var MediaSourceContentInitializer = /** @class */ (function (_super) {
         this._initCanceller.cancel();
     };
     MediaSourceContentInitializer.prototype._onFatalError = function (err) {
-        if (this._initCanceller.isUsed) {
+        if (this._initCanceller.isUsed()) {
             return;
         }
         this._initCanceller.cancel();
@@ -184,12 +184,9 @@ var MediaSourceContentInitializer = /** @class */ (function (_super) {
     };
     MediaSourceContentInitializer.prototype._initializeMediaSourceAndDecryption = function (mediaElement, protectionRef) {
         var _this = this;
-        return new Promise(function (resolve, reject) {
+        var initCanceller = this._initCanceller;
+        return createCancellablePromise(initCanceller.signal, function (resolve) {
             var keySystems = _this._settings.keySystems;
-            var initCanceller = _this._initCanceller;
-            var unregisterReject = initCanceller.signal.register(function (err) {
-                reject(err);
-            });
             /** Initialize decryption capabilities. */
             var drmInitRef = initializeContentDecryption(mediaElement, keySystems, protectionRef, {
                 onWarning: function (err) { return _this.trigger("warning", err); },
@@ -200,9 +197,8 @@ var MediaSourceContentInitializer = /** @class */ (function (_super) {
                     return;
                 }
                 stopListeningToDrmUpdates();
-                var mediaSourceCanceller = new TaskCanceller({
-                    cancelOn: initCanceller.signal,
-                });
+                var mediaSourceCanceller = new TaskCanceller();
+                mediaSourceCanceller.linkToSignal(initCanceller.signal);
                 openMediaSource(mediaElement, mediaSourceCanceller.signal)
                     .then(function (mediaSource) {
                     var lastDrmStatus = drmInitRef.getValue();
@@ -211,7 +207,6 @@ var MediaSourceContentInitializer = /** @class */ (function (_super) {
                         drmInitRef.onUpdate(function (newDrmStatus, stopListeningToDrmUpdatesAgain) {
                             if (newDrmStatus.initializationState.type === "initialized") {
                                 stopListeningToDrmUpdatesAgain();
-                                unregisterReject();
                                 resolve({ mediaSource: mediaSource, drmSystemId: newDrmStatus.drmSystemId,
                                     unlinkMediaSource: mediaSourceCanceller });
                                 return;
@@ -219,14 +214,13 @@ var MediaSourceContentInitializer = /** @class */ (function (_super) {
                         }, { emitCurrentValue: true, clearSignal: initCanceller.signal });
                     }
                     else if (drmStatus.initializationState.type === "initialized") {
-                        unregisterReject();
                         resolve({ mediaSource: mediaSource, drmSystemId: drmStatus.drmSystemId,
                             unlinkMediaSource: mediaSourceCanceller });
                         return;
                     }
                 })
                     .catch(function (err) {
-                    if (mediaSourceCanceller.isUsed) {
+                    if (mediaSourceCanceller.isUsed()) {
                         return;
                     }
                     _this._onFatalError(err);
@@ -252,20 +246,21 @@ var MediaSourceContentInitializer = /** @class */ (function (_super) {
                 bufferOnMediaSource(opts, onReloadMediaSource, currentCanceller.signal);
                 function onReloadMediaSource(reloadOrder) {
                     currentCanceller.cancel();
-                    if (initCanceller.isUsed) {
+                    if (initCanceller.isUsed()) {
                         return;
                     }
-                    triggerEvent("reloadingMediaSource", null);
-                    if (initCanceller.isUsed) {
+                    triggerEvent("reloadingMediaSource", reloadOrder);
+                    if (initCanceller.isUsed()) {
                         return;
                     }
-                    var newCanceller = new TaskCanceller({ cancelOn: initCanceller.signal });
+                    var newCanceller = new TaskCanceller();
+                    newCanceller.linkToSignal(initCanceller.signal);
                     openMediaSource(mediaElement, newCanceller.signal)
                         .then(function (newMediaSource) {
                         recursivelyLoadOnMediaSource(newMediaSource, reloadOrder.position, reloadOrder.autoPlay, newCanceller);
                     })
                         .catch(function (err) {
-                        if (newCanceller.isUsed) {
+                        if (newCanceller.isUsed()) {
                             return;
                         }
                         onFatalError(err);
@@ -302,7 +297,7 @@ var MediaSourceContentInitializer = /** @class */ (function (_super) {
                         subBufferOptions = objectAssign({ textTrackOptions: textTrackOptions, drmSystemId: drmSystemId }, bufferOptions);
                         segmentFetcherCreator = new SegmentFetcherCreator(transport, segmentRequestOptions, initCanceller.signal);
                         this.trigger("manifestReady", manifest);
-                        if (initCanceller.isUsed) {
+                        if (initCanceller.isUsed()) {
                             return [2 /*return*/];
                         }
                         bufferOnMediaSource = this._startBufferingOnMediaSource.bind(this);
@@ -336,7 +331,7 @@ var MediaSourceContentInitializer = /** @class */ (function (_super) {
             segmentBuffersStore.disposeAll();
         });
         var _b = performInitialSeekAndPlay(mediaElement, playbackObserver, initialTime, autoPlay, function (err) { return _this.trigger("warning", err); }, cancelSignal), autoPlayResult = _b.autoPlayResult, initialPlayPerformed = _b.initialPlayPerformed, initialSeekPerformed = _b.initialSeekPerformed;
-        if (cancelSignal.isCancelled) {
+        if (cancelSignal.isCancelled()) {
             return;
         }
         initialPlayPerformed.onUpdate(function (isPerformed, stopListening) {
@@ -346,7 +341,18 @@ var MediaSourceContentInitializer = /** @class */ (function (_super) {
             }
         }, { clearSignal: cancelSignal, emitCurrentValue: true });
         var streamObserver = createStreamPlaybackObserver(manifest, playbackObserver, { autoPlay: autoPlay, initialPlayPerformed: initialPlayPerformed, initialSeekPerformed: initialSeekPerformed, speed: speed, startTime: initialTime });
-        var rebufferingController = this._createRebufferingController(playbackObserver, manifest, speed, cancelSignal);
+        var rebufferingController = this._createRebufferingController(playbackObserver, manifest, segmentBuffersStore, speed, cancelSignal);
+        rebufferingController.addEventListener("needsReload", function () {
+            // NOTE couldn't both be always calculated at event destination?
+            // Maybe there are exceptions?
+            var position = initialSeekPerformed.getValue() ?
+                playbackObserver.getCurrentTime() :
+                initialTime;
+            var autoplay = initialPlayPerformed.getValue() ?
+                !playbackObserver.getIsPaused() :
+                autoPlay;
+            onReloadOrder({ position: position, autoPlay: autoplay });
+        }, cancelSignal);
         var contentTimeBoundariesObserver = this
             ._createContentTimeBoundariesObserver(manifest, mediaSource, streamObserver, segmentBuffersStore, cancelSignal);
         /**
@@ -365,7 +371,7 @@ var MediaSourceContentInitializer = /** @class */ (function (_super) {
             }, { emitCurrentValue: true, clearSignal: cancelSignal });
         })
             .catch(function (err) {
-            if (cancelSignal.isCancelled) {
+            if (cancelSignal.isCancelled()) {
                 return; // Current loading cancelled, no need to trigger the error
             }
             _this._onFatalError(err);
@@ -381,7 +387,32 @@ var MediaSourceContentInitializer = /** @class */ (function (_super) {
         function handleStreamOrchestratorCallbacks() {
             return {
                 needsBufferFlush: function () {
-                    return playbackObserver.setCurrentTime(mediaElement.currentTime + 0.001);
+                    var seekedTime = mediaElement.currentTime + 0.001;
+                    playbackObserver.setCurrentTime(seekedTime);
+                    // Seek again once data begins to be buffered.
+                    // This is sadly necessary on some browsers to avoid decoding
+                    // issues after a flush.
+                    //
+                    // NOTE: there's in theory a potential race condition in the following
+                    // logic as the callback could be called when media data is still
+                    // being removed by the browser - which is an asynchronous process.
+                    // The following condition checking for buffered data could thus lead
+                    // to a false positive where we're actually checking previous data.
+                    // For now, such scenario is avoided by setting the
+                    // `includeLastObservation` option to `false` and calling
+                    // `needsBufferFlush` once MSE media removal operations have been
+                    // explicitely validated by the browser, but that's a complex and easy
+                    // to break system.
+                    playbackObserver.listen(function (obs, stopListening) {
+                        if (
+                        // Data is buffered around the current position
+                        obs.currentRange !== null ||
+                            // Or, for whatever reason, playback is already advancing
+                            obs.position > seekedTime + 0.1) {
+                            stopListening();
+                            playbackObserver.setCurrentTime(obs.position + 0.001);
+                        }
+                    }, { includeLastObservation: false, clearSignal: cancelSignal });
                 },
                 streamStatusUpdate: function (value) {
                     // Announce discontinuities if found
@@ -392,7 +423,7 @@ var MediaSourceContentInitializer = /** @class */ (function (_super) {
                         discontinuity: imminentDiscontinuity,
                         position: position,
                     });
-                    if (cancelSignal.isCancelled) {
+                    if (cancelSignal.isCancelled()) {
                         return; // Previous call has stopped streams due to a side-effect
                     }
                     // If the status for the last Period indicates that segments are all loaded
@@ -429,14 +460,14 @@ var MediaSourceContentInitializer = /** @class */ (function (_super) {
                 },
                 adaptationChange: function (value) {
                     self.trigger("adaptationChange", value);
-                    if (cancelSignal.isCancelled) {
+                    if (cancelSignal.isCancelled()) {
                         return; // Previous call has stopped streams due to a side-effect
                     }
                     contentTimeBoundariesObserver.onAdaptationChange(value.type, value.period, value.adaptation);
                 },
                 representationChange: function (value) {
                     self.trigger("representationChange", value);
-                    if (cancelSignal.isCancelled) {
+                    if (cancelSignal.isCancelled()) {
                         return; // Previous call has stopped streams due to a side-effect
                     }
                     contentTimeBoundariesObserver.onRepresentationChange(value.type, value.period);
@@ -446,7 +477,7 @@ var MediaSourceContentInitializer = /** @class */ (function (_super) {
                 periodStreamReady: function (value) { return self.trigger("periodStreamReady", value); },
                 periodStreamCleared: function (value) {
                     contentTimeBoundariesObserver.onPeriodCleared(value.type, value.period);
-                    if (cancelSignal.isCancelled) {
+                    if (cancelSignal.isCancelled()) {
                         return; // Previous call has stopped streams due to a side-effect
                     }
                     self.trigger("periodStreamCleared", value);
@@ -476,7 +507,7 @@ var MediaSourceContentInitializer = /** @class */ (function (_super) {
                     for (var _i = 0, value_1 = value; _i < value_1.length; _i++) {
                         var protectionData = value_1[_i];
                         protectionRef.setValue(protectionData);
-                        if (cancelSignal.isCancelled) {
+                        if (cancelSignal.isCancelled()) {
                             return; // Previous call has stopped streams due to a side-effect
                         }
                     }
@@ -503,9 +534,9 @@ var MediaSourceContentInitializer = /** @class */ (function (_super) {
     MediaSourceContentInitializer.prototype._createContentTimeBoundariesObserver = function (manifest, mediaSource, streamObserver, segmentBuffersStore, cancelSignal) {
         var _this = this;
         /** Maintains the MediaSource's duration up-to-date with the Manifest */
-        var mediaDurationUpdater = new MediaDurationUpdater(manifest, mediaSource);
+        var mediaSourceDurationUpdater = new MediaSourceDurationUpdater(mediaSource);
         cancelSignal.register(function () {
-            mediaDurationUpdater.stop();
+            mediaSourceDurationUpdater.stopUpdating();
         });
         /** Allows to cancel a pending `end-of-stream` operation. */
         var endOfStreamCanceller = null;
@@ -520,12 +551,12 @@ var MediaSourceContentInitializer = /** @class */ (function (_super) {
             _this.trigger("activePeriodChanged", { period: period });
         });
         contentTimeBoundariesObserver.addEventListener("durationUpdate", function (newDuration) {
-            log.debug("Init: Duration has to be updated.", newDuration);
-            mediaDurationUpdater.updateKnownDuration(newDuration);
+            mediaSourceDurationUpdater.updateDuration(newDuration.duration, newDuration.isEnd);
         });
         contentTimeBoundariesObserver.addEventListener("endOfStream", function () {
             if (endOfStreamCanceller === null) {
-                endOfStreamCanceller = new TaskCanceller({ cancelOn: cancelSignal });
+                endOfStreamCanceller = new TaskCanceller();
+                endOfStreamCanceller.linkToSignal(cancelSignal);
                 log.debug("Init: end-of-stream order received.");
                 maintainEndOfStream(mediaSource, endOfStreamCanceller.signal);
             }
@@ -537,6 +568,8 @@ var MediaSourceContentInitializer = /** @class */ (function (_super) {
                 endOfStreamCanceller = null;
             }
         });
+        var currentDuration = contentTimeBoundariesObserver.getCurrentDuration();
+        mediaSourceDurationUpdater.updateDuration(currentDuration.duration, currentDuration.isEnd);
         return contentTimeBoundariesObserver;
     };
     /**
@@ -557,9 +590,9 @@ var MediaSourceContentInitializer = /** @class */ (function (_super) {
      * @param {Object} cancelSignal
      * @returns {Object}
      */
-    MediaSourceContentInitializer.prototype._createRebufferingController = function (playbackObserver, manifest, speed, cancelSignal) {
+    MediaSourceContentInitializer.prototype._createRebufferingController = function (playbackObserver, manifest, segmentBuffersStore, speed, cancelSignal) {
         var _this = this;
-        var rebufferingController = new RebufferingController(playbackObserver, manifest, speed);
+        var rebufferingController = new RebufferingController(playbackObserver, manifest, segmentBuffersStore, speed);
         // Bubble-up events
         rebufferingController.addEventListener("stalled", function (evt) { return _this.trigger("stalled", evt); });
         rebufferingController.addEventListener("unstalled", function () { return _this.trigger("unstalled", null); });

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

@@ -95,7 +95,15 @@ export interface IContentInitializerEvents {
      * Event sent when we're starting attach a new MediaSource to the media element
      * (after removing the previous one).
      */
-    reloadingMediaSource: null;
+    reloadingMediaSource: {
+        /** The position we're reloading at, in seconds. */
+        position: number;
+        /**
+         * If `true`, we'll play directly after finishing the reloading operation.
+         * If `false`, we'll be paused after it.
+         */
+        autoPlay: boolean;
+    };
     /** Event sent after the player stalled. */
     stalled: IStallingSituation;
     /** Event sent when the player goes out of a stalling situation. */

package/dist/_esm5.processed/core/init/utils/content_time_boundaries_observer.d.ts

@@ -55,6 +55,11 @@ export default class ContentTimeBoundariesObserver extends EventEmitter<IContent
      * @param {Object} playbackObserver
      */
     constructor(manifest: Manifest, playbackObserver: IReadOnlyPlaybackObserver<IStreamOrchestratorPlaybackObservation>, bufferTypes: IBufferType[]);
+    /**
+     * Returns an estimate of the current duration of the content.
+     * @returns {Object}
+     */
+    getCurrentDuration(): IDurationItem;
     /**
      * Method to call any time an Adaptation has been selected.
      *
@@ -121,9 +126,31 @@ export default class ContentTimeBoundariesObserver extends EventEmitter<IContent
     private _addActivelyLoadedPeriod;
     private _removeActivelyLoadedPeriod;
     private _checkCurrentPeriod;
+    private _getManifestDuration;
     private _lazilyCreateActiveStreamInfo;
     private _checkEndOfStream;
 }
+export interface IDurationItem {
+    /**
+     * The new maximum known position (note that this is the ending position
+     * currently known of the current content, it might be superior to the last
+     * position at which segments are available and it might also evolve over
+     * time), in seconds.
+     */
+    duration: number;
+    /**
+     * If `true`, the communicated `duration` is the actual end of the content.
+     * It may still be updated due to a track change or to add precision, but it
+     * is still a (rough) estimate of the maximum position that content should
+     * have.
+     *
+     * If `false`, this is the currently known maximum position associated to
+     * the content, but the content is still evolving (typically, new media
+     * segments are still being generated) and as such it can still have a
+     * longer duration in the future.
+     */
+    isEnd: boolean;
+}
 /**
  * Events triggered by a `ContentTimeBoundariesObserver` where the keys are the
  * event names and the value is the payload of those events.
@@ -137,7 +164,7 @@ export interface IContentTimeBoundariesObserverEvent {
      * Triggered when the duration of the currently-playing content became known
      * or changed.
      */
-    durationUpdate: number | undefined;
+    durationUpdate: IDurationItem;
     /**
      * Triggered when the last possible chronological segment for all types of
      * buffers has either been pushed or is being pushed to the corresponding

package/dist/_esm5.processed/core/init/utils/content_time_boundaries_observer.js

@@ -82,19 +82,21 @@ var ContentTimeBoundariesObserver = /** @class */ (function (_super) {
             }
         }, { includeLastObservation: true, clearSignal: cancelSignal });
         manifest.addEventListener("manifestUpdate", function () {
-            _this.trigger("durationUpdate", getManifestDuration());
-            if (cancelSignal.isCancelled) {
+            _this.trigger("durationUpdate", _this._getManifestDuration());
+            if (cancelSignal.isCancelled()) {
                 return;
             }
             _this._checkEndOfStream();
         }, cancelSignal);
-        function getManifestDuration() {
-            return manifest.isDynamic ?
-                maximumPositionCalculator.getMaximumAvailablePosition() :
-                maximumPositionCalculator.getEndingPosition();
-        }
         return _this;
     }
+    /**
+     * Returns an estimate of the current duration of the content.
+     * @returns {Object}
+     */
+    ContentTimeBoundariesObserver.prototype.getCurrentDuration = function () {
+        return this._getManifestDuration();
+    };
     /**
      * Method to call any time an Adaptation has been selected.
      *
@@ -121,14 +123,17 @@ var ContentTimeBoundariesObserver = /** @class */ (function (_super) {
                         this._maximumPositionCalculator
                             .updateLastVideoAdaptation(adaptation);
                     }
-                    var newDuration = this._manifest.isDynamic ?
-                        this._maximumPositionCalculator.getMaximumAvailablePosition() :
-                        this._maximumPositionCalculator.getEndingPosition();
+                    var endingPosition = this._maximumPositionCalculator.getEndingPosition();
+                    var newDuration = endingPosition !== undefined ?
+                        { isEnd: true,
+                            duration: endingPosition } :
+                        { isEnd: false,
+                            duration: this._maximumPositionCalculator.getMaximumAvailablePosition() };
                     this.trigger("durationUpdate", newDuration);
                 }
             }
         }
-        if (this._canceller.isUsed) {
+        if (this._canceller.isUsed()) {
             return;
         }
         if (adaptation === null) {
@@ -258,6 +263,14 @@ var ContentTimeBoundariesObserver = /** @class */ (function (_super) {
                 return state_1.value;
         }
     };
+    ContentTimeBoundariesObserver.prototype._getManifestDuration = function () {
+        var endingPosition = this._maximumPositionCalculator.getEndingPosition();
+        return endingPosition !== undefined ?
+            { isEnd: true,
+                duration: endingPosition } :
+            { isEnd: false,
+                duration: this._maximumPositionCalculator.getMaximumAvailablePosition() };
+    };
     ContentTimeBoundariesObserver.prototype._lazilyCreateActiveStreamInfo = function (bufferType) {
         var streamInfo = this._activeStreams.get(bufferType);
         if (streamInfo === undefined) {

package/dist/_esm5.processed/core/init/utils/create_media_source.js

@@ -16,8 +16,8 @@
 import { clearElementSrc, events, MediaSource_, } from "../../../compat";
 import { MediaError } from "../../../errors";
 import log from "../../../log";
+import createCancellablePromise from "../../../utils/create_cancellable_promise";
 import isNonEmptyString from "../../../utils/is_non_empty_string";
-import TaskCanceller from "../../../utils/task_canceller";
 /**
  * Dispose of ressources taken by the MediaSource:
  *   - Clear the MediaSource' SourceBuffers
@@ -100,19 +100,10 @@ function createMediaSource(mediaElement, unlinkSignal) {
  * @returns {Promise}
  */
 export default function openMediaSource(mediaElement, unlinkSignal) {
-    return new Promise(function (resolve, reject) {
-        var hasResolved = false;
+    return createCancellablePromise(unlinkSignal, function (resolve) {
         var mediaSource = createMediaSource(mediaElement, unlinkSignal);
-        var eventListenerCanceller = new TaskCanceller({ cancelOn: unlinkSignal });
         events.onSourceOpen(mediaSource, function () {
-            eventListenerCanceller.cancel();
-            hasResolved = true;
             resolve(mediaSource);
-        }, eventListenerCanceller.signal);
-        unlinkSignal.register(function (error) {
-            if (!hasResolved) {
-                reject(error);
-            }
-        });
+        }, unlinkSignal);
     });
 }

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

@@ -55,7 +55,8 @@ export default function triggerEndOfStream(mediaSource, cancelSignal) {
         return;
     }
     log.debug("Init: Waiting SourceBuffers to be updated before calling endOfStream.");
-    var innerCanceller = new TaskCanceller({ cancelOn: cancelSignal });
+    var innerCanceller = new TaskCanceller();
+    innerCanceller.linkToSignal(cancelSignal);
     for (var _i = 0, updatingSourceBuffers_1 = updatingSourceBuffers; _i < updatingSourceBuffers_1.length; _i++) {
         var sourceBuffer = updatingSourceBuffers_1[_i];
         onSourceBufferUpdate(sourceBuffer, function () {
@@ -75,10 +76,12 @@ export default function triggerEndOfStream(mediaSource, cancelSignal) {
  * @param {Object} cancelSignal
  */
 export function maintainEndOfStream(mediaSource, cancelSignal) {
-    var endOfStreamCanceller = new TaskCanceller({ cancelOn: cancelSignal });
+    var endOfStreamCanceller = new TaskCanceller();
+    endOfStreamCanceller.linkToSignal(cancelSignal);
     onSourceOpen(mediaSource, function () {
         endOfStreamCanceller.cancel();
-        endOfStreamCanceller = new TaskCanceller({ cancelOn: cancelSignal });
+        endOfStreamCanceller = new TaskCanceller();
+        endOfStreamCanceller.linkToSignal(cancelSignal);
         triggerEndOfStream(mediaSource, endOfStreamCanceller.signal);
     }, cancelSignal);
     triggerEndOfStream(mediaSource, endOfStreamCanceller.signal);