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

package/dist/_esm5.processed/core/adaptive/guess_based_chooser.js

@@ -127,10 +127,10 @@ var GuessBasedChooser = /** @class */ (function () {
      * @returns {boolean}
      */
     GuessBasedChooser.prototype._canGuessHigher = function (bufferGap, speed, _a) {
-        var score = _a[0], scoreConfidenceLevel = _a[1];
+        var score = _a.score, confidenceLevel = _a.confidenceLevel;
         return isFinite(bufferGap) && bufferGap >= 2.5 &&
             performance.now() > this._blockGuessesUntil &&
-            scoreConfidenceLevel === 1 /* ScoreConfidenceLevel.HIGH */ &&
+            confidenceLevel === 1 /* ScoreConfidenceLevel.HIGH */ &&
             score / speed > 1.01;
     };
     /**
@@ -143,10 +143,10 @@ var GuessBasedChooser = /** @class */ (function () {
      * @returns {boolean}
      */
     GuessBasedChooser.prototype._shouldStopGuess = function (lastGuess, scoreData, bufferGap, requests) {
-        if (scoreData !== undefined && scoreData[0] < 1.01) {
+        if (scoreData !== undefined && scoreData.score < 1.01) {
             return true;
         }
-        else if ((scoreData === undefined || scoreData[0] < 1.2) && bufferGap < 0.6) {
+        else if ((scoreData === undefined || scoreData.score < 1.2) && bufferGap < 0.6) {
             return true;
         }
         var guessedRepresentationRequests = requests.filter(function (req) {
@@ -175,8 +175,8 @@ var GuessBasedChooser = /** @class */ (function () {
     };
     GuessBasedChooser.prototype._isLastGuessValidated = function (lastGuess, incomingBestBitrate, scoreData) {
         if (scoreData !== undefined &&
-            scoreData[1] === 1 /* ScoreConfidenceLevel.HIGH */ &&
-            scoreData[0] > 1.5) {
+            scoreData.confidenceLevel === 1 /* ScoreConfidenceLevel.HIGH */ &&
+            scoreData.score > 1.5) {
             return true;
         }
         return incomingBestBitrate >= lastGuess.bitrate &&

package/dist/_esm5.processed/core/adaptive/network_analyzer.js

@@ -126,6 +126,12 @@ function estimateStarvationModeBitrate(pendingRequests, playbackInfo, currentRep
     }
     var concernedRequest = concernedRequests[0];
     var now = performance.now();
+    var minimumRequestTime = concernedRequest.content.segment.duration * 1.5;
+    minimumRequestTime = Math.min(minimumRequestTime, 3000);
+    minimumRequestTime = Math.max(minimumRequestTime, 12000);
+    if (now - concernedRequest.requestTimestamp < minimumRequestTime) {
+        return undefined;
+    }
     var lastProgressEvent = concernedRequest.progress.length > 0 ?
         concernedRequest.progress[concernedRequest.progress.length - 1] :
         undefined;
@@ -138,7 +144,7 @@ function estimateStarvationModeBitrate(pendingRequests, playbackInfo, currentRep
             // Calculate estimated time spent rebuffering if we continue doing that request.
             var expectedRebufferingTime = remainingTime -
                 (realBufferGap / speed);
-            if (expectedRebufferingTime > 2000) {
+            if (expectedRebufferingTime > 2500) {
                 return bandwidthEstimate;
             }
         }
@@ -320,12 +326,9 @@ var NetworkAnalyzer = /** @class */ (function () {
         if (currentRepresentation === null) {
             return true;
         }
-        else if (bitrate === currentRepresentation.bitrate) {
+        else if (bitrate >= currentRepresentation.bitrate) {
             return false;
         }
-        else if (bitrate > currentRepresentation.bitrate) {
-            return !this._inStarvationMode;
-        }
         return shouldDirectlySwitchToLowBitrate(playbackInfo, currentRequests, this._lowLatencyMode);
     };
     return NetworkAnalyzer;

package/dist/_esm5.processed/core/adaptive/utils/representation_score_calculator.d.ts

@@ -14,6 +14,24 @@
  * limitations under the License.
  */
 import { Representation } from "../../../manifest";
+/**
+ * Object representing a maintainability score as calculated by the
+ * `RepresentationScoreCalculator`.
+ */
+export interface IRepresentationMaintainabilityScore {
+    /**
+     * Weighted mean of dividing the loaded segment's duration by the time to make
+     * their request.
+     */
+    score: number;
+    /**
+     * The confidence we have on the calculated `score` in reflecting a useful
+     * maintainability hint for the concerned Representation.
+     *
+     * Basically, the more segments have been loaded, the higher the confidence.
+     */
+    confidenceLevel: ScoreConfidenceLevel;
+}
 /**
  * Calculate the "maintainability score" of a given Representation:
  *   - A score higher than 1 means that the Representation can theorically
@@ -62,7 +80,7 @@ export default class RepresentationScoreCalculator {
      * @param {Representation} representation
      * @returns {number|undefined}
      */
-    getEstimate(representation: Representation): [number, ScoreConfidenceLevel] | undefined;
+    getEstimate(representation: Representation): IRepresentationMaintainabilityScore | undefined;
     /**
      * Returns last Representation which had reached a score superior to 1.
      * This Representation is the last known one which could be maintained.

package/dist/_esm5.processed/core/adaptive/utils/representation_score_calculator.js

@@ -96,7 +96,7 @@ var RepresentationScoreCalculator = /** @class */ (function () {
         var confidenceLevel = loadedSegments >= 5 &&
             loadedDuration >= 10 ? 1 /* ScoreConfidenceLevel.HIGH */ :
             0 /* ScoreConfidenceLevel.LOW */;
-        return [estimate, confidenceLevel];
+        return { score: estimate, confidenceLevel: confidenceLevel };
     };
     /**
      * Returns last Representation which had reached a score superior to 1.

package/dist/_esm5.processed/core/api/debug/render.js

@@ -21,7 +21,7 @@ export default function renderDebugElement(parentElt, instance, cancelSignal) {
     debugWrapperElt.style.backgroundColor = "#00000099";
     debugWrapperElt.style.padding = "7px";
     debugWrapperElt.style.fontSize = "13px";
-    debugWrapperElt.style.fontFamily = "mono";
+    debugWrapperElt.style.fontFamily = "mono, monospace";
     debugWrapperElt.style.color = "white";
     debugWrapperElt.style.display = "inline-block";
     debugWrapperElt.style.bottom = "0px";

package/dist/_esm5.processed/core/api/playback_observer.js

@@ -114,6 +114,7 @@ var PlaybackObserver = /** @class */ (function () {
      */
     PlaybackObserver.prototype.setCurrentTime = function (time) {
         this._internalSeeksIncoming.push(time);
+        log.info("API: Seeking internally", time);
         this._mediaElement.currentTime = time;
     };
     /**

package/dist/_esm5.processed/core/api/public_api.d.ts

@@ -15,7 +15,7 @@
  */
 import { IErrorCode, IErrorType } from "../../errors";
 import Manifest, { Adaptation, Representation } from "../../manifest";
-import { IAudioRepresentation, IAudioTrack, IAudioTrackSetting, IAvailableAudioTrack, IAvailableTextTrack, IAvailableVideoTrack, IBrokenRepresentationsLockContext, IConstructorOptions, IKeySystemConfigurationOutput, ILoadVideoOptions, ILockedAudioRepresentationsSettings, ILockedVideoRepresentationsSettings, ITrackUpdateEventPayload, IPeriod, IPeriodChangeEvent, IPlayerError, IPlayerState, IPositionUpdate, IStreamEvent, ITextTrack, IVideoRepresentation, ITextTrackSetting, IVideoTrack, IVideoTrackSetting } from "../../public_types";
+import { IAudioRepresentation, IAudioTrack, IAudioTrackSetting, IAvailableAudioTrack, IAvailableTextTrack, IAvailableVideoTrack, IBrokenRepresentationsLockContext, IConstructorOptions, IKeySystemConfigurationOutput, ILoadVideoOptions, ILockedAudioRepresentationsSettings, ILockedVideoRepresentationsSettings, ITrackUpdateEventPayload, IRepresentationListUpdateContext, IPeriod, IPeriodChangeEvent, IPlayerError, IPlayerState, IPositionUpdate, IStreamEvent, ITextTrack, IVideoRepresentation, ITextTrackSetting, IVideoTrack, IVideoTrackSetting } from "../../public_types";
 import EventEmitter, { IListener } from "../../utils/event_emitter";
 import Logger from "../../utils/logger";
 import { IBufferedChunk, IBufferType } from "../segment_buffers";
@@ -95,6 +95,10 @@ declare class Player extends EventEmitter<IPublicAPIEvent> {
      * It should refer to the last content being played.
      */
     private _priv_reloadingMetadata;
+    /**
+     * Store last value of autoPlay, from the last load or reload.
+     */
+    private _priv_lastAutoPlay;
     /** All possible Error types emitted by the RxPlayer. */
     static get ErrorTypes(): Record<IErrorType, IErrorType>;
     /** All possible Error codes emitted by the RxPlayer. */
@@ -178,6 +182,26 @@ declare class Player extends EventEmitter<IPublicAPIEvent> {
      * @returns {string} - The current Player's state
      */
     getPlayerState(): string;
+    /**
+     * Returns true if a content is loaded.
+     * @returns {Boolean} - `true` if a content is loaded, `false` otherwise.
+     */
+    isContentLoaded(): boolean;
+    /**
+     * Returns true if the player is buffering.
+     * @returns {Boolean} - `true` if the player is buffering, `false` otherwise.
+     */
+    isBuffering(): boolean;
+    /**
+     * Returns the play/pause status of the player :
+     *   - when `LOADING` or `RELOADING`, returns the scheduled play/pause condition
+     *     for when loading is over,
+     *   - in other states, returns the `<video>` element .paused value,
+     *   - if the player is disposed, returns `true`.
+     * @returns {Boolean} - `true` if the player is paused or will be after loading,
+     * `false` otherwise.
+     */
+    isPaused(): boolean;
     /**
      * Returns true if both:
      *   - a content is loaded
@@ -250,6 +274,12 @@ declare class Player extends EventEmitter<IPublicAPIEvent> {
      * @returns {Number}
      */
     getPosition(): number;
+    /**
+     * Returns the last stored content position, in seconds.
+     *
+     * @returns {number|undefined}
+     */
+    getLastStoredContentPosition(): number | undefined;
     /**
      * Returns the current playback rate at which the video plays.
      * @returns {Number}
@@ -630,6 +660,26 @@ declare class Player extends EventEmitter<IPublicAPIEvent> {
      */
     private _priv_initializeMediaElementTracksStore;
     private _priv_callTracksStoreGetterSetter;
+    /**
+     * Method to call when some event lead to a high for possibility that the
+     * available tracks for the given type have changed.
+     * Send the corresponding `available*Tracks` change event with the last
+     * available tracks.
+     *
+     * @param {string} trackType
+     * @param {Object|undefined} [oPeriodRef] - optional period object used by the
+     * `tracksStore` API, allows to optimize the method by bypassing this step.
+     */
+    private _priv_onAvailableTracksMayHaveChanged;
+    /**
+     * Method to call when a fatal error lead to the stopping of the current
+     * content.
+     *
+     * @param {*} err - The error encountered.
+     * @param {Object} contentInfos - The `IPublicApiContentInfos` object linked
+     * to the content for which the error was received.
+     */
+    private _priv_onFatalError;
 }
 /** Every events sent by the RxPlayer's public API. */
 interface IPublicAPIEvent {
@@ -647,9 +697,12 @@ interface IPublicAPIEvent {
     availableAudioTracksChange: IAvailableAudioTrack[];
     availableTextTracksChange: IAvailableTextTrack[];
     availableVideoTracksChange: IAvailableVideoTrack[];
+    play: null;
+    pause: null;
     newAvailablePeriods: IPeriod[];
     brokenRepresentationsLock: IBrokenRepresentationsLockContext;
     trackUpdate: ITrackUpdateEventPayload;
+    representationListUpdate: IRepresentationListUpdateContext;
     seeking: null;
     seeked: null;
     streamEvent: IStreamEvent;

package/dist/_esm5.processed/core/api/public_api.js

@@ -50,6 +50,8 @@ import config from "../../config";
 import { ErrorCodes, ErrorTypes, formatError, MediaError, } from "../../errors";
 import features from "../../features";
 import log from "../../log";
+import arrayFind from "../../utils/array_find";
+import arrayIncludes from "../../utils/array_includes";
 import assert from "../../utils/assert";
 import assertUnreachable from "../../utils/assert_unreachable";
 import EventEmitter from "../../utils/event_emitter";
@@ -64,7 +66,7 @@ import MediaSourceContentInitializer from "../init/media_source_content_initiali
 import { checkReloadOptions, parseConstructorOptions, parseLoadVideoOptions, } from "./option_utils";
 import PlaybackObserver from "./playback_observer";
 import TracksStore from "./track_management/tracks_store";
-import { constructPlayerStateReference, emitSeekEvents, isLoadedState, } from "./utils";
+import { constructPlayerStateReference, emitPlayPauseEvents, emitSeekEvents, isLoadedState, } from "./utils";
 /* eslint-disable @typescript-eslint/naming-convention */
 var generateContentId = idGenerator();
 var getPictureOnPictureStateRef = events.getPictureOnPictureStateRef, getVideoVisibilityRef = events.getVideoVisibilityRef, getElementResolutionRef = events.getElementResolutionRef, getScreenResolutionRef = events.getScreenResolutionRef;
@@ -86,7 +88,7 @@ var Player = /** @class */ (function (_super) {
         // Workaround to support Firefox autoplay on FF 42.
         // See: https://bugzilla.mozilla.org/show_bug.cgi?id=1194624
         videoElement.preload = "auto";
-        _this.version = /* PLAYER_VERSION */ "4.0.0-beta.1";
+        _this.version = /* PLAYER_VERSION */ "4.0.0-beta.2";
         _this.log = log;
         _this.state = "STOPPED";
         _this.videoElement = videoElement;
@@ -114,6 +116,7 @@ var Player = /** @class */ (function (_super) {
         _this._priv_contentEventsMemory = {};
         _this._priv_setPlayerState("STOPPED" /* PLAYER_STATES.STOPPED */);
         _this._priv_reloadingMetadata = {};
+        _this._priv_lastAutoPlay = false;
         return _this;
     }
     Object.defineProperty(Player, "ErrorTypes", {
@@ -211,6 +214,7 @@ var Player = /** @class */ (function (_super) {
         log.info("API: Calling loadvideo", options.url, options.transport);
         this._priv_reloadingMetadata = { options: options };
         this._priv_initializeContentPlayback(options);
+        this._priv_lastAutoPlay = options.autoPlay;
     };
     /**
      * Reload the last loaded content.
@@ -386,23 +390,7 @@ var Player = /** @class */ (function (_super) {
         };
         // Bind events
         initializer.addEventListener("error", function (error) {
-            var formattedError = formatError(error, {
-                defaultCode: "NONE",
-                defaultReason: "An unknown error stopped content playback.",
-            });
-            formattedError.fatal = true;
-            contentInfos.currentContentCanceller.cancel();
-            _this._priv_cleanUpCurrentContentState();
-            _this._priv_currentError = formattedError;
-            log.error("API: The player stopped because of an error", error instanceof Error ? error : "");
-            _this._priv_setPlayerState("STOPPED" /* PLAYER_STATES.STOPPED */);
-            // TODO This condition is here because the eventual callback called when the
-            // player state is updated can launch a new content, thus the error will not
-            // be here anymore, in which case triggering the "error" event is unwanted.
-            // This is very ugly though, and we should probable have a better solution
-            if (_this._priv_currentError === formattedError) {
-                _this.trigger("error", formattedError);
-            }
+            _this._priv_onFatalError(error, contentInfos);
         });
         initializer.addEventListener("warning", function (error) {
             var formattedError = formatError(error, {
@@ -412,11 +400,12 @@ var Player = /** @class */ (function (_super) {
             log.warn("API: Sending warning:", formattedError);
             _this.trigger("warning", formattedError);
         });
-        initializer.addEventListener("reloadingMediaSource", function () {
+        initializer.addEventListener("reloadingMediaSource", function (payload) {
             contentInfos.segmentBuffersStore = null;
             if (contentInfos.tracksStore !== null) {
                 contentInfos.tracksStore.resetPeriodObjects();
             }
+            _this._priv_lastAutoPlay = payload.autoPlay;
         });
         initializer.addEventListener("inbandEvents", function (inbandEvents) {
             return _this.trigger("inbandEvents", inbandEvents);
@@ -500,6 +489,48 @@ var Player = /** @class */ (function (_super) {
                     break;
             }
         };
+        /**
+         * `TaskCanceller` allowing to stop emitting `"play"` and `"pause"`
+         * events.
+         * `null` when such events are not emitted currently.
+         */
+        var playPauseEventsCanceller = null;
+        /**
+         * Callback emitting `"play"` and `"pause`" events once the content is
+         * loaded, starting from the state indicated in argument.
+         * @param {boolean} willAutoPlay - If `false`, we're currently paused.
+         */
+        var triggerPlayPauseEventsWhenReady = function (willAutoPlay) {
+            if (playPauseEventsCanceller !== null) {
+                playPauseEventsCanceller.cancel(); // cancel previous logic
+                playPauseEventsCanceller = null;
+            }
+            playerStateRef.onUpdate(function (val, stopListeningToStateUpdates) {
+                if (!isLoadedState(val)) {
+                    return; // content not loaded yet: no event
+                }
+                stopListeningToStateUpdates();
+                if (playPauseEventsCanceller !== null) {
+                    playPauseEventsCanceller.cancel();
+                }
+                playPauseEventsCanceller = new TaskCanceller();
+                playPauseEventsCanceller.linkToSignal(currentContentCanceller.signal);
+                if (willAutoPlay !== !videoElement.paused) {
+                    // paused status is not at the expected value on load: emit event
+                    if (videoElement.paused) {
+                        _this.trigger("pause", null);
+                    }
+                    else {
+                        _this.trigger("play", null);
+                    }
+                }
+                emitPlayPauseEvents(videoElement, function () { return _this.trigger("play", null); }, function () { return _this.trigger("pause", null); }, currentContentCanceller.signal);
+            }, { emitCurrentValue: false, clearSignal: currentContentCanceller.signal });
+        };
+        triggerPlayPauseEventsWhenReady(autoPlay);
+        initializer.addEventListener("reloadingMediaSource", function (payload) {
+            triggerPlayPauseEventsWhenReady(payload.autoPlay);
+        });
         /**
          * `TaskCanceller` allowing to stop emitting `"seeking"` and `"seeked"`
          * events.
@@ -569,6 +600,40 @@ var Player = /** @class */ (function (_super) {
     Player.prototype.getPlayerState = function () {
         return this.state;
     };
+    /**
+     * Returns true if a content is loaded.
+     * @returns {Boolean} - `true` if a content is loaded, `false` otherwise.
+     */
+    Player.prototype.isContentLoaded = function () {
+        return !arrayIncludes(["LOADING", "RELOADING", "STOPPED"], this.state);
+    };
+    /**
+     * Returns true if the player is buffering.
+     * @returns {Boolean} - `true` if the player is buffering, `false` otherwise.
+     */
+    Player.prototype.isBuffering = function () {
+        return arrayIncludes(["BUFFERING", "SEEKING", "LOADING", "RELOADING"], this.state);
+    };
+    /**
+     * Returns the play/pause status of the player :
+     *   - when `LOADING` or `RELOADING`, returns the scheduled play/pause condition
+     *     for when loading is over,
+     *   - in other states, returns the `<video>` element .paused value,
+     *   - if the player is disposed, returns `true`.
+     * @returns {Boolean} - `true` if the player is paused or will be after loading,
+     * `false` otherwise.
+     */
+    Player.prototype.isPaused = function () {
+        if (this.videoElement) {
+            if (arrayIncludes(["LOADING", "RELOADING"], this.state)) {
+                return !this._priv_lastAutoPlay;
+            }
+            else {
+                return this.videoElement.paused;
+            }
+        }
+        return true;
+    };
     /**
      * Returns true if both:
      *   - a content is loaded
@@ -709,6 +774,14 @@ var Player = /** @class */ (function (_super) {
         }
         return this.videoElement.currentTime;
     };
+    /**
+     * Returns the last stored content position, in seconds.
+     *
+     * @returns {number|undefined}
+     */
+    Player.prototype.getLastStoredContentPosition = function () {
+        return this._priv_reloadingMetadata.reloadPosition;
+    };
     /**
      * Returns the current playback rate at which the video plays.
      * @returns {Number}
@@ -909,6 +982,7 @@ var Player = /** @class */ (function (_super) {
         if (positionWanted === undefined) {
             throw new Error("invalid time given");
         }
+        log.info("API: API Seek to", positionWanted);
         this.videoElement.currentTime = positionWanted;
         return positionWanted;
     };
@@ -1555,20 +1629,32 @@ var Player = /** @class */ (function (_super) {
             return; // Event for another content
         }
         contentInfos.manifest = manifest;
-        var cancelSignal = contentInfos.currentContentCanceller.signal;
         this._priv_reloadingMetadata.manifest = manifest;
-        contentInfos.tracksStore = new TracksStore({
+        var tracksStore = new TracksStore({
             preferTrickModeTracks: this._priv_preferTrickModeTracks,
             defaultAudioTrackSwitchingMode: contentInfos.defaultAudioTrackSwitchingMode,
         });
-        contentInfos.tracksStore.addEventListener("newAvailablePeriods", function (p) {
+        contentInfos.tracksStore = tracksStore;
+        tracksStore.addEventListener("newAvailablePeriods", function (p) {
             _this.trigger("newAvailablePeriods", p);
         });
-        contentInfos.tracksStore.addEventListener("brokenRepresentationsLock", function (e) {
+        tracksStore.addEventListener("brokenRepresentationsLock", function (e) {
             _this.trigger("brokenRepresentationsLock", e);
         });
-        contentInfos.tracksStore.addEventListener("trackUpdate", function (e) {
+        tracksStore.addEventListener("trackUpdate", function (e) {
+            var _a, _b;
             _this.trigger("trackUpdate", e);
+            var currentPeriod = (_b = (_a = _this._priv_contentInfos) === null || _a === void 0 ? void 0 : _a.currentPeriod) !== null && _b !== void 0 ? _b : undefined;
+            if (e.reason === "no-playable-representation" &&
+                e.period.id === (currentPeriod === null || currentPeriod === void 0 ? void 0 : currentPeriod.id)) {
+                _this._priv_onAvailableTracksMayHaveChanged(e.trackType);
+            }
+        });
+        contentInfos.tracksStore.addEventListener("warning", function (err) {
+            _this.trigger("warning", err);
+        });
+        contentInfos.tracksStore.addEventListener("error", function (err) {
+            _this._priv_onFatalError(err, contentInfos);
         });
         contentInfos.tracksStore.updatePeriodList(manifest);
         manifest.addEventListener("manifestUpdate", function (updates) {
@@ -1578,8 +1664,8 @@ var Player = /** @class */ (function (_super) {
                 contentInfos.tracksStore.updatePeriodList(manifest);
             }
             var currentPeriod = (_b = (_a = _this._priv_contentInfos) === null || _a === void 0 ? void 0 : _a.currentPeriod) !== null && _b !== void 0 ? _b : undefined;
-            var tracksStore = (_c = _this._priv_contentInfos) === null || _c === void 0 ? void 0 : _c.tracksStore;
-            if (currentPeriod === undefined || isNullOrUndefined(tracksStore)) {
+            var currTracksStore = (_c = _this._priv_contentInfos) === null || _c === void 0 ? void 0 : _c.tracksStore;
+            if (currentPeriod === undefined || isNullOrUndefined(currTracksStore)) {
                 return;
             }
             for (var _i = 0, _d = updates.updatedPeriods; _i < _d.length; _i++) {
@@ -1588,21 +1674,64 @@ var Player = /** @class */ (function (_super) {
                     if (update.result.addedAdaptations.length > 0 ||
                         update.result.removedAdaptations.length > 0) {
                         // We might have new (or less) tracks, send events just to be sure
-                        var periodRef = tracksStore.getPeriodObjectFromPeriod(currentPeriod);
+                        var periodRef = currTracksStore.getPeriodObjectFromPeriod(currentPeriod);
                         if (periodRef === undefined) {
                             return;
                         }
-                        var audioTracks = tracksStore.getAvailableAudioTracks(periodRef);
-                        _this._priv_triggerEventIfNotStopped("availableAudioTracksChange", audioTracks !== null && audioTracks !== void 0 ? audioTracks : [], cancelSignal);
-                        var textTracks = tracksStore.getAvailableTextTracks(periodRef);
-                        _this._priv_triggerEventIfNotStopped("availableTextTracksChange", textTracks !== null && textTracks !== void 0 ? textTracks : [], cancelSignal);
-                        var videoTracks = tracksStore.getAvailableVideoTracks(periodRef);
-                        _this._priv_triggerEventIfNotStopped("availableVideoTracksChange", videoTracks !== null && videoTracks !== void 0 ? videoTracks : [], cancelSignal);
+                        _this._priv_onAvailableTracksMayHaveChanged("audio");
+                        _this._priv_onAvailableTracksMayHaveChanged("text");
+                        _this._priv_onAvailableTracksMayHaveChanged("video");
                     }
                 }
                 return;
             }
         }, contentInfos.currentContentCanceller.signal);
+        manifest.addEventListener("decipherabilityUpdate", function (elts) {
+            /**
+             * Array of tuples only including once the Period/Track combination, and
+             * only when it concerns the currently-selected track.
+             */
+            var periodsAndTrackTypes = elts.reduce(function (acc, elt) {
+                var _a, _b, _c;
+                var isFound = arrayFind(acc, function (x) { return x[0].id === elt.period.id &&
+                    x[1] === elt.adaptation.type; }) === undefined;
+                if (!isFound) {
+                    // Only consider the currently-selected tracks.
+                    // NOTE: Maybe there's room for optimizations? Unclear.
+                    var tStore = contentInfos.tracksStore;
+                    if (tStore === null) {
+                        return acc;
+                    }
+                    var isCurrent = false;
+                    var periodRef = tStore.getPeriodObjectFromPeriod(elt.period);
+                    if (periodRef === undefined) {
+                        return acc;
+                    }
+                    switch (elt.adaptation.type) {
+                        case "audio":
+                            isCurrent = ((_a = tStore
+                                .getChosenAudioTrack(periodRef)) === null || _a === void 0 ? void 0 : _a.id) === elt.adaptation.id;
+                            break;
+                        case "video":
+                            isCurrent = ((_b = tStore
+                                .getChosenVideoTrack(periodRef)) === null || _b === void 0 ? void 0 : _b.id) === elt.adaptation.id;
+                            break;
+                        case "text":
+                            isCurrent = ((_c = tStore
+                                .getChosenTextTrack(periodRef)) === null || _c === void 0 ? void 0 : _c.id) === elt.adaptation.id;
+                            break;
+                    }
+                    if (isCurrent) {
+                        acc.push([elt.period, elt.adaptation.type]);
+                    }
+                }
+                return acc;
+            }, []);
+            for (var _i = 0, periodsAndTrackTypes_1 = periodsAndTrackTypes; _i < periodsAndTrackTypes_1.length; _i++) {
+                var _a = periodsAndTrackTypes_1[_i], period = _a[0], trackType = _a[1];
+                _this._priv_triggerEventIfNotStopped("representationListUpdate", { period: period, trackType: trackType, reason: "decipherability-update" }, contentInfos.currentContentCanceller.signal);
+            }
+        }, contentInfos.currentContentCanceller.signal);
     };
     /**
      * Triggered each times the current Period Changed.
@@ -1962,7 +2091,75 @@ var Player = /** @class */ (function (_super) {
         }
         return cb(tracksStore, periodRef);
     };
+    /**
+     * Method to call when some event lead to a high for possibility that the
+     * available tracks for the given type have changed.
+     * Send the corresponding `available*Tracks` change event with the last
+     * available tracks.
+     *
+     * @param {string} trackType
+     * @param {Object|undefined} [oPeriodRef] - optional period object used by the
+     * `tracksStore` API, allows to optimize the method by bypassing this step.
+     */
+    Player.prototype._priv_onAvailableTracksMayHaveChanged = function (trackType, oPeriodRef) {
+        var contentInfos = this._priv_contentInfos;
+        if (contentInfos === null) {
+            return;
+        }
+        var currentPeriod = contentInfos.currentPeriod, tracksStore = contentInfos.tracksStore, currentContentCanceller = contentInfos.currentContentCanceller;
+        var cancelSignal = currentContentCanceller.signal;
+        if (isNullOrUndefined(currentPeriod) || tracksStore === null) {
+            return;
+        }
+        var periodRef = oPeriodRef !== null && oPeriodRef !== void 0 ? oPeriodRef : tracksStore.getPeriodObjectFromPeriod(currentPeriod);
+        if (periodRef === undefined) {
+            return;
+        }
+        switch (trackType) {
+            case "video":
+                var videoTracks = tracksStore.getAvailableVideoTracks(periodRef);
+                this._priv_triggerEventIfNotStopped("availableVideoTracksChange", videoTracks !== null && videoTracks !== void 0 ? videoTracks : [], cancelSignal);
+                break;
+            case "audio":
+                var audioTracks = tracksStore.getAvailableAudioTracks(periodRef);
+                this._priv_triggerEventIfNotStopped("availableAudioTracksChange", audioTracks !== null && audioTracks !== void 0 ? audioTracks : [], cancelSignal);
+                break;
+            case "text":
+                var textTracks = tracksStore.getAvailableTextTracks(periodRef);
+                this._priv_triggerEventIfNotStopped("availableTextTracksChange", textTracks !== null && textTracks !== void 0 ? textTracks : [], cancelSignal);
+                break;
+            default:
+                assertUnreachable(trackType);
+        }
+    };
+    /**
+     * Method to call when a fatal error lead to the stopping of the current
+     * content.
+     *
+     * @param {*} err - The error encountered.
+     * @param {Object} contentInfos - The `IPublicApiContentInfos` object linked
+     * to the content for which the error was received.
+     */
+    Player.prototype._priv_onFatalError = function (err, contentInfos) {
+        var formattedError = formatError(err, {
+            defaultCode: "NONE",
+            defaultReason: "An unknown error stopped content playback.",
+        });
+        formattedError.fatal = true;
+        contentInfos.currentContentCanceller.cancel();
+        this._priv_cleanUpCurrentContentState();
+        this._priv_currentError = formattedError;
+        log.error("API: The player stopped because of an error", formattedError);
+        this._priv_setPlayerState("STOPPED" /* PLAYER_STATES.STOPPED */);
+        // TODO This condition is here because the eventual callback called when the
+        // player state is updated can launch a new content, thus the error will not
+        // be here anymore, in which case triggering the "error" event is unwanted.
+        // This is very ugly though, and we should probable have a better solution
+        if (this._priv_currentError === formattedError) {
+            this.trigger("error", formattedError);
+        }
+    };
     return Player;
 }(EventEmitter));
-Player.version = /* PLAYER_VERSION */ "4.0.0-beta.1";
+Player.version = /* PLAYER_VERSION */ "4.0.0-beta.2";
 export default Player;

package/dist/_esm5.processed/core/api/track_management/media_element_tracks_store.js

@@ -102,7 +102,14 @@ function createTextTracks(textTracks) {
             "_" +
             occurences.toString();
         languagesOccurences[language] = occurences + 1;
-        var track = { language: textTrack.language, id: id, normalized: normalizeLanguage(textTrack.language),
+        // Safari seems to be indicating that the subtitles track is a forced
+        // subtitles track by setting the `kind` attribute to `"forced"`.
+        // As of now (2023-04-04), this is not standard.
+        // @see https://github.com/whatwg/html/issues/4472
+        var forced = textTrack.kind === "forced" ?
+            true :
+            undefined;
+        var track = { language: textTrack.language, forced: forced, label: textTrack.label, id: id, normalized: normalizeLanguage(textTrack.language),
             closedCaption: textTrack.kind === "captions" };
         newTextTracks.push({ track: track, nativeTrack: textTrack });
     }
@@ -293,6 +300,8 @@ var MediaElementTracksStore = /** @class */ (function (_super) {
         return this._textTracks.map(function (_a) {
             var track = _a.track, nativeTrack = _a.nativeTrack;
             return { id: track.id,
+                label: track.label,
+                forced: track.forced,
                 language: track.language,
                 normalized: track.normalized,
                 closedCaption: track.closedCaption,