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

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.0";
+        _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.
@@ -254,6 +258,18 @@ var Player = /** @class */ (function (_super) {
         }
         this._priv_initializeContentPlayback(newOptions);
     };
+    Player.prototype.createDebugElement = function (element) {
+        if (features.createDebugElement === null) {
+            throw new Error("Feature `DEBUG_ELEMENT` not added to the RxPlayer");
+        }
+        var canceller = new TaskCanceller();
+        features.createDebugElement(element, this, canceller.signal);
+        return {
+            dispose: function () {
+                canceller.cancel();
+            },
+        };
+    };
     /**
      * From given options, initialize content playback.
      * @param {Object} options
@@ -351,7 +367,7 @@ var Player = /** @class */ (function (_super) {
             }
             mediaElementTracksStore =
                 this._priv_initializeMediaElementTracksStore(currentContentCanceller.signal);
-            if (currentContentCanceller.isUsed) {
+            if (currentContentCanceller.isUsed()) {
                 return;
             }
             initializer = new features.directfile.initDirectFile({ autoPlay: autoPlay, keySystems: keySystems, speed: this._priv_speed, startAt: startAt, url: url });
@@ -374,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, {
@@ -400,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);
@@ -488,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.
@@ -498,7 +541,7 @@ var Player = /** @class */ (function (_super) {
         playerStateRef.onUpdate(function (newState) {
             updateReloadingMetadata(newState);
             _this._priv_setPlayerState(newState);
-            if (currentContentCanceller.isUsed) {
+            if (currentContentCanceller.isUsed()) {
                 return;
             }
             if (seekEventsCanceller !== null) {
@@ -508,9 +551,8 @@ var Player = /** @class */ (function (_super) {
                 }
             }
             else if (isLoadedState(_this.state)) {
-                seekEventsCanceller = new TaskCanceller({
-                    cancelOn: currentContentCanceller.signal,
-                });
+                seekEventsCanceller = new TaskCanceller();
+                seekEventsCanceller.linkToSignal(currentContentCanceller.signal);
                 emitSeekEvents(videoElement, playbackObserver, function () { return _this.trigger("seeking", null); }, function () { return _this.trigger("seeked", null); }, seekEventsCanceller.signal);
             }
         }, { emitCurrentValue: true, clearSignal: currentContentCanceller.signal });
@@ -558,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
@@ -698,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}
@@ -791,7 +875,7 @@ var Player = /** @class */ (function (_super) {
      * @returns {Object|null|undefined}
      */
     Player.prototype.getVideoRepresentation = function () {
-        var representations = this._priv_getCurrentRepresentations();
+        var representations = this.__priv_getCurrentRepresentations();
         if (representations === null) {
             return undefined;
         }
@@ -807,7 +891,7 @@ var Player = /** @class */ (function (_super) {
      * @returns {Object|null|undefined}
      */
     Player.prototype.getAudioRepresentation = function () {
-        var representations = this._priv_getCurrentRepresentations();
+        var representations = this.__priv_getCurrentRepresentations();
         if (representations === null) {
             return undefined;
         }
@@ -898,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;
     };
@@ -1462,12 +1547,39 @@ var Player = /** @class */ (function (_super) {
      * null if the player is STOPPED.
      * @returns {Manifest|null} - The current Manifest (`null` when not known).
      */
+    // TODO remove the need for that public method
     Player.prototype.__priv_getManifest = function () {
         if (this._priv_contentInfos === null) {
             return null;
         }
         return this._priv_contentInfos.manifest;
     };
+    // TODO remove the need for that public method
+    Player.prototype.__priv_getCurrentAdaptation = function () {
+        if (this._priv_contentInfos === null) {
+            return null;
+        }
+        var _a = this._priv_contentInfos, currentPeriod = _a.currentPeriod, activeAdaptations = _a.activeAdaptations;
+        if (currentPeriod === null ||
+            activeAdaptations === null ||
+            isNullOrUndefined(activeAdaptations[currentPeriod.id])) {
+            return null;
+        }
+        return activeAdaptations[currentPeriod.id];
+    };
+    // TODO remove the need for that public method
+    Player.prototype.__priv_getCurrentRepresentations = function () {
+        if (this._priv_contentInfos === null) {
+            return null;
+        }
+        var _a = this._priv_contentInfos, currentPeriod = _a.currentPeriod, activeRepresentations = _a.activeRepresentations;
+        if (currentPeriod === null ||
+            activeRepresentations === null ||
+            isNullOrUndefined(activeRepresentations[currentPeriod.id])) {
+            return null;
+        }
+        return activeRepresentations[currentPeriod.id];
+    };
     // ---- Private methods ----
     /**
      * Reset all state properties relative to a playing content.
@@ -1517,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) {
@@ -1540,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++) {
@@ -1550,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.
@@ -1608,12 +1775,9 @@ var Player = /** @class */ (function (_super) {
             this._priv_triggerEventIfNotStopped("textTrackChange", null, cancelSignal);
             this._priv_triggerEventIfNotStopped("videoTrackChange", null, cancelSignal);
         }
-        var audioRepresentation = (_e = (_d = this._priv_getCurrentRepresentations()) === null || _d === void 0 ? void 0 : _d.audio) !== null && _e !== void 0 ? _e : null;
+        var audioRepresentation = (_e = (_d = this.__priv_getCurrentRepresentations()) === null || _d === void 0 ? void 0 : _d.audio) !== null && _e !== void 0 ? _e : null;
         this._priv_triggerEventIfNotStopped("audioRepresentationChange", audioRepresentation, cancelSignal);
-        if (contentInfos.currentContentCanceller.isUsed) {
-            return;
-        }
-        var videoRepresentation = (_g = (_f = this._priv_getCurrentRepresentations()) === null || _f === void 0 ? void 0 : _f.video) !== null && _g !== void 0 ? _g : null;
+        var videoRepresentation = (_g = (_f = this.__priv_getCurrentRepresentations()) === null || _f === void 0 ? void 0 : _f.video) !== null && _g !== void 0 ? _g : null;
         this._priv_triggerEventIfNotStopped("videoRepresentationChange", videoRepresentation, cancelSignal);
     };
     /**
@@ -1854,25 +2018,13 @@ var Player = /** @class */ (function (_super) {
         }
         this.trigger("positionUpdate", positionData);
     };
-    Player.prototype._priv_getCurrentRepresentations = function () {
-        if (this._priv_contentInfos === null) {
-            return null;
-        }
-        var _a = this._priv_contentInfos, currentPeriod = _a.currentPeriod, activeRepresentations = _a.activeRepresentations;
-        if (currentPeriod === null ||
-            activeRepresentations === null ||
-            isNullOrUndefined(activeRepresentations[currentPeriod.id])) {
-            return null;
-        }
-        return activeRepresentations[currentPeriod.id];
-    };
     /**
      * @param {string} evt
      * @param {*} arg
      * @param {Object} currentContentCancelSignal
      */
     Player.prototype._priv_triggerEventIfNotStopped = function (evt, arg, currentContentCancelSignal) {
-        if (!currentContentCancelSignal.isCancelled) {
+        if (!currentContentCancelSignal.isCancelled()) {
             this.trigger(evt, arg);
         }
     };
@@ -1939,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.0";
+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,

package/dist/_esm5.processed/core/api/track_management/track_dispatcher.d.ts

@@ -30,6 +30,14 @@ export default class TrackDispatcher extends EventEmitter<ITrackDispatcherEvent>
     private _lastEmitted;
     /** Interface allowing to clean-up resources when they are not needed anymore. */
     private _canceller;
+    /**
+     * Boolean set to `true` when a track-updating method is called and to `false`
+     * just before it performs the actual track change to allow checking for
+     * re-entrancy: if the token is already reset to `false` before the
+     * track change is officialized, then another track update has already been
+     * performed in the meantime.
+     */
+    private _updateToken;
     /**
      * Create a new `TrackDispatcher` by giving its Reference and an initial track
      * setting.
@@ -37,9 +45,12 @@ export default class TrackDispatcher extends EventEmitter<ITrackDispatcherEvent>
      * synchronously.
      * @param {Object} manifest
      * @param {Object} adaptationRef
+     */
+    constructor(manifest: Manifest, adaptationRef: ISharedReference<IAdaptationChoice | null | undefined>);
+    /**
      * @param {Object|null} initialTrackInfo
      */
-    constructor(manifest: Manifest, adaptationRef: ISharedReference<IAdaptationChoice | null | undefined>, initialTrackInfo: ITrackSetting | null);
+    start(initialTrackInfo: ITrackSetting | null): void;
     /**
      * Update the wanted track on the Reference linked to this `TrackDispatcher`.
      * @param {Object|null} newTrackInfo
@@ -65,6 +76,7 @@ export interface ITrackDispatcherEvent {
      * none of them are currently "playable".
      */
     noPlayableLockedRepresentation: null;
+    noPlayableRepresentation: null;
 }
 /** Define a new Track preference given to the `TrackDispatcher`. */
 export interface ITrackSetting {