rx-player 3.29.0-dev.2022090500 → 3.29.0-dev.2022091500

package/CHANGELOG.md

@@ -1,12 +1,14 @@
 # Changelog
 
-## v3.29.0-dev.2022090500 (2022-09-05)
+## v3.29.0-dev.2022091300 (2022-09-15)
 
 ### Features
 
   - add `networkConfig.segmentRequestTimeout` and `networkConfig.manifestRequestTimeout` options to loadVideo to configure the timeout of respectively segment and manifest requests [#1156]
   - add `timeout` property to the first argument communicated to a `segmentLoader` (from `loadVideo`'s `transportOptions`) [#1156]
   - add `timeout` property to a new third argument communicated to a `manifestLoader` (from `loadVideo`'s `transportOptions`) [#1156]
+  - add `keySystems[].onKeyExpiration` to `loadVideo` options to configure the behavior the RxPlayer should have on key expiration [#1157]
+  - add `keyStatuses` property to an `EncryptedMediaError` with the `KEY_STATUS_CHANGE_ERROR` code to communicate which key id and key statuses caused issues. [#1157]
 
 ### Bug fixes
 
@@ -19,6 +21,7 @@
 ### Other improvements
 
   - In the experimental "local" transport, add `incomingRanges` property to signal the time ranges of remaining data, allowing better discontinuity handling and duration estimates for sill-loading dowloaded contents [#1151]
+  - Only send through `"warning"` events, just one `EncryptedMediaError` with a `KEY_STATUS_CHANGE_ERROR` code when multiple ones arises at the same time [#1157]
 
 ## v3.28.0 (2022-07-12)
 

package/VERSION

@@ -1 +1 @@
-3.29.0-dev.2022090500
+3.29.0-dev.2022091500

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

@@ -269,14 +269,14 @@ function checkReloadOptions(options) {
  * @returns {Object}
  */
 function parseLoadVideoOptions(options) {
-    var _a, _b, _c, _d, _e, _f;
+    var _a, _b, _c, _d, _e, _f, _g;
     var url;
     var transport;
     var keySystems;
     var textTrackMode;
     var textTrackElement;
     var startAt;
-    var _g = config.getCurrent(), DEFAULT_AUDIO_TRACK_SWITCHING_MODE = _g.DEFAULT_AUDIO_TRACK_SWITCHING_MODE, DEFAULT_AUTO_PLAY = _g.DEFAULT_AUTO_PLAY, DEFAULT_CODEC_SWITCHING_BEHAVIOR = _g.DEFAULT_CODEC_SWITCHING_BEHAVIOR, DEFAULT_ENABLE_FAST_SWITCHING = _g.DEFAULT_ENABLE_FAST_SWITCHING, DEFAULT_MANUAL_BITRATE_SWITCHING_MODE = _g.DEFAULT_MANUAL_BITRATE_SWITCHING_MODE, DEFAULT_SHOW_NATIVE_SUBTITLE = _g.DEFAULT_SHOW_NATIVE_SUBTITLE, DEFAULT_TEXT_TRACK_MODE = _g.DEFAULT_TEXT_TRACK_MODE;
+    var _h = config.getCurrent(), DEFAULT_AUDIO_TRACK_SWITCHING_MODE = _h.DEFAULT_AUDIO_TRACK_SWITCHING_MODE, DEFAULT_AUTO_PLAY = _h.DEFAULT_AUTO_PLAY, DEFAULT_CODEC_SWITCHING_BEHAVIOR = _h.DEFAULT_CODEC_SWITCHING_BEHAVIOR, DEFAULT_ENABLE_FAST_SWITCHING = _h.DEFAULT_ENABLE_FAST_SWITCHING, DEFAULT_MANUAL_BITRATE_SWITCHING_MODE = _h.DEFAULT_MANUAL_BITRATE_SWITCHING_MODE, DEFAULT_SHOW_NATIVE_SUBTITLE = _h.DEFAULT_SHOW_NATIVE_SUBTITLE, DEFAULT_TEXT_TRACK_MODE = _h.DEFAULT_TEXT_TRACK_MODE;
     if (isNullOrUndefined(options)) {
         throw new Error("No option set on loadVideo");
     }
@@ -363,8 +363,8 @@ function parseLoadVideoOptions(options) {
             "Please use the `TextTrackRenderer` tool instead.");
         var supplementaryTextTracks = Array.isArray(options.supplementaryTextTracks) ?
             options.supplementaryTextTracks : [options.supplementaryTextTracks];
-        for (var _h = 0, supplementaryTextTracks_1 = supplementaryTextTracks; _h < supplementaryTextTracks_1.length; _h++) {
-            var supplementaryTextTrack = supplementaryTextTracks_1[_h];
+        for (var _j = 0, supplementaryTextTracks_1 = supplementaryTextTracks; _j < supplementaryTextTracks_1.length; _j++) {
+            var supplementaryTextTrack = supplementaryTextTracks_1[_j];
             if (typeof supplementaryTextTrack.language !== "string" ||
                 typeof supplementaryTextTrack.mimeType !== "string" ||
                 typeof supplementaryTextTrack.url !== "string") {
@@ -379,8 +379,8 @@ function parseLoadVideoOptions(options) {
             "Please use the `parseBifThumbnails` tool instead.");
         var supplementaryImageTracks = Array.isArray(options.supplementaryImageTracks) ?
             options.supplementaryImageTracks : [options.supplementaryImageTracks];
-        for (var _j = 0, supplementaryImageTracks_1 = supplementaryImageTracks; _j < supplementaryImageTracks_1.length; _j++) {
-            var supplementaryImageTrack = supplementaryImageTracks_1[_j];
+        for (var _k = 0, supplementaryImageTracks_1 = supplementaryImageTracks; _k < supplementaryImageTracks_1.length; _k++) {
+            var supplementaryImageTrack = supplementaryImageTracks_1[_k];
             if (typeof supplementaryImageTrack.mimeType !== "string" ||
                 typeof supplementaryImageTrack.url !== "string") {
                 throw new Error("Invalid supplementary image track given. " +
@@ -448,11 +448,7 @@ function parseLoadVideoOptions(options) {
             startAt = options.startAt;
         }
     }
-    var networkConfig = isNullOrUndefined(options.networkConfig) ?
-        {} :
-        { manifestRetry: options.networkConfig.manifestRetry,
-            offlineRetry: options.networkConfig.offlineRetry,
-            segmentRetry: options.networkConfig.segmentRetry };
+    var networkConfig = (_g = options.networkConfig) !== null && _g !== void 0 ? _g : {};
     // TODO without cast
     /* eslint-disable @typescript-eslint/consistent-type-assertions */
     return { autoPlay: autoPlay, defaultAudioTrack: defaultAudioTrack, defaultTextTrack: defaultTextTrack, enableFastSwitching: enableFastSwitching, hideNativeSubtitle: hideNativeSubtitle, keySystems: keySystems, initialManifest: initialManifest, lowLatencyMode: lowLatencyMode, manualBitrateSwitchingMode: manualBitrateSwitchingMode, audioTrackSwitchingMode: audioTrackSwitchingMode, minimumManifestUpdateInterval: minimumManifestUpdateInterval, networkConfig: networkConfig, onCodecSwitch: onCodecSwitch, startAt: startAt, textTrackElement: textTrackElement, textTrackMode: textTrackMode, transport: transport, transportOptions: transportOptions, url: url };

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

@@ -38,7 +38,7 @@ declare class Player extends EventEmitter<IPublicAPIEvent> {
     readonly log: Logger;
     /**
      * Current state of the RxPlayer.
-     * Please use `getPlayerState()` instead.
+     * Please use `getLoadedContentState()` instead.
      */
     state: IPlayerState;
     /**
@@ -351,9 +351,9 @@ declare class Player extends EventEmitter<IPublicAPIEvent> {
      *
      * Note that switching to or getting out of a trickmode video track may
      * lead to the player being a brief instant in a `"RELOADING"` state (notified
-     * through `playerStateChange` events and the `getPlayerState` method). When in
-     * that state, a black screen may be displayed and multiple RxPlayer APIs will
-     * not be usable.
+     * through `playerStateChange` events and the `getLoadedContentState` method).
+     * When in that state, a black screen may be displayed and multiple RxPlayer
+     * APIs will not be usable.
      *
      * @param {Number} rate
      * @param {Object} opts

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

@@ -63,11 +63,10 @@ import warnOnce from "../../utils/warn_once";
 import { clearOnStop, disposeDecryptionResources, getCurrentKeySystem, } from "../decrypt";
 import { ManifestFetcher, SegmentFetcherCreator, } from "../fetchers";
 import initializeMediaSourcePlayback from "../init";
-import emitSeekEvents from "./emit_seek_events";
-import getPlayerState, { PLAYER_STATES, } from "./get_player_state";
 import { checkReloadOptions, parseConstructorOptions, parseLoadVideoOptions, } from "./option_utils";
 import PlaybackObserver from "./playback_observer";
-import TrackChoiceManager from "./track_choice_manager";
+import TrackChoiceManager from "./tracks_management/track_choice_manager";
+import { emitSeekEvents, getLoadedContentState, } from "./utils";
 /* eslint-disable @typescript-eslint/naming-convention */
 var getPageActivityRef = events.getPageActivityRef, getPictureOnPictureStateRef = events.getPictureOnPictureStateRef, getVideoVisibilityRef = events.getVideoVisibilityRef, getVideoWidthRef = events.getVideoWidthRef, onFullscreenChange$ = events.onFullscreenChange$, onTextTrackChanges$ = events.onTextTrackChanges$;
 /**
@@ -88,7 +87,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 */ "3.29.0-dev.2022090500";
+        _this.version = /* PLAYER_VERSION */ "3.29.0-dev.2022091500";
         _this.log = log;
         _this.state = "STOPPED";
         _this.videoElement = videoElement;
@@ -160,7 +159,7 @@ var Player = /** @class */ (function (_super) {
         _this._priv_contentInfos = null;
         _this._priv_contentEventsMemory = {};
         _this._priv_stopAtEnd = stopAtEnd;
-        _this._priv_setPlayerState(PLAYER_STATES.STOPPED);
+        _this._priv_setPlayerState("STOPPED" /* PLAYER_STATES.STOPPED */);
         _this._priv_preferredAudioTracks = preferredAudioTracks;
         _this._priv_preferredTextTracks = preferredTextTracks;
         _this._priv_preferredVideoTracks = preferredVideoTracks;
@@ -227,8 +226,8 @@ var Player = /** @class */ (function (_super) {
             this._priv_contentInfos.currentContentCanceller.cancel();
         }
         this._priv_cleanUpCurrentContentState();
-        if (this.state !== PLAYER_STATES.STOPPED) {
-            this._priv_setPlayerState(PLAYER_STATES.STOPPED);
+        if (this.state !== "STOPPED" /* PLAYER_STATES.STOPPED */) {
+            this._priv_setPlayerState("STOPPED" /* PLAYER_STATES.STOPPED */);
         }
     };
     /**
@@ -550,18 +549,18 @@ var Player = /** @class */ (function (_super) {
             stateChangingEvent$.pipe(startWith(null)),
         ]).pipe(takeUntil(stoppedContent$), map(function (_a) {
             var stalledStatus = _a[0];
-            return getPlayerState(videoElement, stalledStatus);
+            return getLoadedContentState(videoElement, stalledStatus);
         }));
         /** Emit all player "state" updates. */
-        var playerState$ = observableConcat(observableOf(PLAYER_STATES.LOADING), // Begin with LOADING
+        var playerState$ = observableConcat(observableOf("LOADING" /* PLAYER_STATES.LOADING */), // Begin with LOADING
         loaded$.pipe(switchMap(function (_, i) {
             var isFirstLoad = i === 0;
             return observableMerge(
             // Purposely subscribed first so a RELOADING triggered synchronously
             // after a LOADED state is catched.
-            reloading$.pipe(map(function () { return PLAYER_STATES.RELOADING; })), 
+            reloading$.pipe(map(function () { return "RELOADING" /* PLAYER_STATES.RELOADING */; })), 
             // Only switch to LOADED state for the first (i.e. non-RELOADING) load
-            isFirstLoad ? observableOf(PLAYER_STATES.LOADED) :
+            isFirstLoad ? observableOf("LOADED" /* PLAYER_STATES.LOADED */) :
                 EMPTY, 
             // Purposely put last so any other state change happens after we've
             // already switched to LOADED
@@ -569,7 +568,7 @@ var Player = /** @class */ (function (_super) {
             // For the first load, we prefer staying at the LOADED state over
             // PAUSED when autoPlay is disabled.
             // For consecutive loads however, there's no LOADED state.
-            skipWhile(function (state) { return isFirstLoad && state === PLAYER_STATES.PAUSED; })));
+            skipWhile(function (state) { return isFirstLoad && state === "PAUSED" /* PLAYER_STATES.PAUSED */; })));
         }))).pipe(distinctUntilChanged());
         var playbackSubscription;
         stoppedContent$.subscribe(function () {
@@ -606,7 +605,7 @@ var Player = /** @class */ (function (_super) {
                     log.info("API: Previous playback finished. Stopping and cleaning-up...");
                     contentInfos.currentContentCanceller.cancel();
                     _this._priv_cleanUpCurrentContentState();
-                    _this._priv_setPlayerState(PLAYER_STATES.STOPPED);
+                    _this._priv_setPlayerState("STOPPED" /* PLAYER_STATES.STOPPED */);
                 }
             },
         });
@@ -911,9 +910,9 @@ var Player = /** @class */ (function (_super) {
      *
      * Note that switching to or getting out of a trickmode video track may
      * lead to the player being a brief instant in a `"RELOADING"` state (notified
-     * through `playerStateChange` events and the `getPlayerState` method). When in
-     * that state, a black screen may be displayed and multiple RxPlayer APIs will
-     * not be usable.
+     * through `playerStateChange` events and the `getLoadedContentState` method).
+     * When in that state, a black screen may be displayed and multiple RxPlayer
+     * APIs will not be usable.
      *
      * @param {Number} rate
      * @param {Object} opts
@@ -1881,7 +1880,7 @@ var Player = /** @class */ (function (_super) {
         this._priv_cleanUpCurrentContentState();
         this._priv_currentError = formattedError;
         log.error("API: The player stopped because of an error", error instanceof Error ? error : "");
-        this._priv_setPlayerState(PLAYER_STATES.STOPPED);
+        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.
@@ -2219,7 +2218,7 @@ var Player = /** @class */ (function (_super) {
             log.warn("API: Cannot perform time update: no content loaded.");
             return;
         }
-        if (this.state === PLAYER_STATES.RELOADING) {
+        if (this.state === "RELOADING" /* PLAYER_STATES.RELOADING */) {
             return;
         }
         var _b = this._priv_contentInfos, isDirectFile = _b.isDirectFile, manifest = _b.manifest;
@@ -2295,5 +2294,5 @@ var Player = /** @class */ (function (_super) {
     };
     return Player;
 }(EventEmitter));
-Player.version = /* PLAYER_VERSION */ "3.29.0-dev.2022090500";
+Player.version = /* PLAYER_VERSION */ "3.29.0-dev.2022091500";
 export default Player;

package/dist/_esm5.processed/core/api/{media_element_track_choice_manager.d.ts → tracks_management/media_element_track_choice_manager.d.ts}

@@ -13,8 +13,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { IAudioTrack, ITextTrack, IVideoTrack, IAudioTrackPreference, ITextTrackPreference, IVideoTrackPreference, IAvailableVideoTrack, IAvailableAudioTrack, IAvailableTextTrack } from "../../public_types";
-import EventEmitter from "../../utils/event_emitter";
+import { IAudioTrack, ITextTrack, IVideoTrack, IAudioTrackPreference, ITextTrackPreference, IVideoTrackPreference, IAvailableVideoTrack, IAvailableAudioTrack, IAvailableTextTrack } from "../../../public_types";
+import EventEmitter from "../../../utils/event_emitter";
 /** Events emitted by the MediaElementTrackChoiceManager. */
 interface IMediaElementTrackChoiceManagerEvents {
     availableVideoTracksChange: IAvailableVideoTrack[];

package/dist/_esm5.processed/core/api/{media_element_track_choice_manager.js → tracks_management/media_element_track_choice_manager.js}

@@ -28,9 +28,9 @@ var __extends = (this && this.__extends) || (function () {
         d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
     };
 })();
-import assert from "../../utils/assert";
-import EventEmitter from "../../utils/event_emitter";
-import normalizeLanguage from "../../utils/languages";
+import assert from "../../../utils/assert";
+import EventEmitter from "../../../utils/event_emitter";
+import normalizeLanguage from "../../../utils/languages";
 /**
  * Check if track array is different from an other one
  * @param {Array.<Object>} oldTrackArray

package/dist/_esm5.processed/core/api/{track_choice_manager.d.ts → tracks_management/track_choice_manager.d.ts}

@@ -18,8 +18,8 @@
  * switching for an easier API management.
  */
 import { Subject } from "rxjs";
-import { Adaptation, Period } from "../../manifest";
-import { IAudioTrack, IAudioTrackPreference, IAvailableAudioTrack, IAvailableTextTrack, IAvailableVideoTrack, ITextTrack, ITextTrackPreference, IVideoTrack, IVideoTrackPreference } from "../../public_types";
+import { Adaptation, Period } from "../../../manifest";
+import { IAudioTrack, IAudioTrackPreference, IAvailableAudioTrack, IAvailableTextTrack, IAvailableVideoTrack, ITextTrack, ITextTrackPreference, IVideoTrack, IVideoTrackPreference } from "../../../public_types";
 /**
  * Manage audio and text tracks for all active periods.
  * Choose the audio and text tracks for each period and record this choice.

package/dist/_esm5.processed/core/api/{track_choice_manager.js → tracks_management/track_choice_manager.js}

@@ -13,13 +13,13 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import log from "../../log";
-import arrayFind from "../../utils/array_find";
-import arrayIncludes from "../../utils/array_includes";
-import isNullOrUndefined from "../../utils/is_null_or_undefined";
-import normalizeLanguage from "../../utils/languages";
-import SortedList from "../../utils/sorted_list";
-import takeFirstSet from "../../utils/take_first_set";
+import log from "../../../log";
+import arrayFind from "../../../utils/array_find";
+import arrayIncludes from "../../../utils/array_includes";
+import isNullOrUndefined from "../../../utils/is_null_or_undefined";
+import normalizeLanguage from "../../../utils/languages";
+import SortedList from "../../../utils/sorted_list";
+import takeFirstSet from "../../../utils/take_first_set";
 /**
  * Transform an array of IAudioTrackPreference into an array of
  * INormalizedPreferredAudioTrack to be exploited by the TrackChoiceManager.

package/dist/_esm5.processed/core/api/{emit_seek_events.d.ts → utils.d.ts}

@@ -14,6 +14,8 @@
  * limitations under the License.
  */
 import { Observable } from "rxjs";
+import { IPlayerState } from "../../public_types";
+import { IStallingSituation } from "../init";
 import { IPlaybackObservation } from "./playback_observer";
 /**
  * Returns Observable which will emit:
@@ -24,4 +26,25 @@ import { IPlaybackObservation } from "./playback_observer";
  * @param {Observable} observation$
  * @returns {Observable}
  */
-export default function emitSeekEvents(mediaElement: HTMLMediaElement | null, observation$: Observable<IPlaybackObservation>): Observable<"seeking" | "seeked">;
+export declare function emitSeekEvents(mediaElement: HTMLMediaElement | null, observation$: Observable<IPlaybackObservation>): Observable<"seeking" | "seeked">;
+/** Player state dictionnary. */
+export declare const enum PLAYER_STATES {
+    STOPPED = "STOPPED",
+    LOADED = "LOADED",
+    LOADING = "LOADING",
+    PLAYING = "PLAYING",
+    PAUSED = "PAUSED",
+    ENDED = "ENDED",
+    BUFFERING = "BUFFERING",
+    SEEKING = "SEEKING",
+    RELOADING = "RELOADING"
+}
+/**
+ * Get state string for a _loaded_ content.
+ * @param {HTMLMediaElement} mediaElement
+ * @param {Object} stalledStatus - Current stalled state:
+ *   - null when not stalled
+ *   - a description of the situation if stalled.
+ * @returns {string}
+ */
+export declare function getLoadedContentState(mediaElement: HTMLMediaElement, stalledStatus: IStallingSituation | null): IPlayerState;

package/dist/_esm5.processed/core/api/{emit_seek_events.js → utils.js}

@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 import { defer as observableDefer, EMPTY, filter, map, merge as observableMerge, startWith, switchMap, take, } from "rxjs";
+import config from "../../config";
 /**
  * Returns Observable which will emit:
  *   - `"seeking"` when we are seeking in the given mediaElement
@@ -23,7 +24,7 @@ import { defer as observableDefer, EMPTY, filter, map, merge as observableMerge,
  * @param {Observable} observation$
  * @returns {Observable}
  */
-export default function emitSeekEvents(mediaElement, observation$) {
+export function emitSeekEvents(mediaElement, observation$) {
     return observableDefer(function () {
         if (mediaElement === null) {
             return EMPTY;
@@ -38,3 +39,33 @@ export default function emitSeekEvents(mediaElement, observation$) {
         return observableMerge(isSeeking$, hasSeeked$);
     });
 }
+/**
+ * Get state string for a _loaded_ content.
+ * @param {HTMLMediaElement} mediaElement
+ * @param {Object} stalledStatus - Current stalled state:
+ *   - null when not stalled
+ *   - a description of the situation if stalled.
+ * @returns {string}
+ */
+export function getLoadedContentState(mediaElement, stalledStatus) {
+    var FORCED_ENDED_THRESHOLD = config.getCurrent().FORCED_ENDED_THRESHOLD;
+    if (mediaElement.ended) {
+        return "ENDED" /* PLAYER_STATES.ENDED */;
+    }
+    if (stalledStatus !== null) {
+        // On some old browsers (e.g. Chrome 54), the browser does not
+        // emit an 'ended' event in some conditions. Detect if we
+        // reached the end by comparing the current position and the
+        // duration instead.
+        var gapBetweenDurationAndCurrentTime = Math.abs(mediaElement.duration -
+            mediaElement.currentTime);
+        if (FORCED_ENDED_THRESHOLD != null &&
+            gapBetweenDurationAndCurrentTime < FORCED_ENDED_THRESHOLD) {
+            return "ENDED" /* PLAYER_STATES.ENDED */;
+        }
+        return stalledStatus === "seeking" ? "SEEKING" /* PLAYER_STATES.SEEKING */ :
+            "BUFFERING" /* PLAYER_STATES.BUFFERING */;
+    }
+    return mediaElement.paused ? "PAUSED" /* PLAYER_STATES.PAUSED */ :
+        "PLAYING" /* PLAYER_STATES.PLAYING */;
+}

package/dist/_esm5.processed/core/decrypt/content_decryptor.d.ts

@@ -143,6 +143,16 @@ export default class ContentDecryptor extends EventEmitter<IContentDecryptorEven
      */
     private _processInitializationData;
     private _tryToUseAlreadyCreatedSession;
+    /**
+     * Callback that should be called if an error that made the current
+     * `ContentDecryptor` instance unusable arised.
+     * This callbacks takes care of resetting state and sending the right events.
+     *
+     * Once called, no further actions should be taken.
+     *
+     * @param {*} err - The error object which describes the issue. Will be
+     * formatted and sent in an "error" event.
+     */
     private _onFatalError;
     /**
      * Return `true` if the `ContentDecryptor` has either been disposed or
@@ -150,8 +160,24 @@ export default class ContentDecryptor extends EventEmitter<IContentDecryptorEven
      * @returns {boolean}
      */
     private _isStopped;
+    /**
+     * Start processing the next initialization data of the `_initDataQueue` if it
+     * isn't lock.
+     */
     private _processCurrentInitDataQueue;
+    /**
+     * Lock new initialization data (from the `_initDataQueue`) from being
+     * processed until `_unlockInitDataQueue` is called.
+     *
+     * You may want to call this method when performing operations which may have
+     * an impact on the handling of other initialization data.
+     */
     private _lockInitDataQueue;
+    /**
+     * Unlock `_initDataQueue` and start processing the first element.
+     *
+     * Should have no effect if the `_initDataQueue` was not locked.
+     */
     private _unlockInitDataQueue;
 }
 /** Events sent by the `ContentDecryptor`, in a `{ event: payload }` format. */

package/dist/_esm5.processed/core/decrypt/content_decryptor.js

@@ -100,6 +100,7 @@ import createOrLoadSession from "./create_or_load_session";
 import initMediaKeys from "./init_media_keys";
 import SessionEventsListener, { BlacklistedSessionError, } from "./session_events_listener";
 import setServerCertificate from "./set_server_certificate";
+import { DecommissionedSessionError } from "./utils/check_key_statuses";
 import cleanOldStoredPersistentInfo from "./utils/clean_old_stored_persistent_info";
 import getDrmSystemId from "./utils/get_drm_system_id";
 import InitDataValuesContainer from "./utils/init_data_values_container";
@@ -351,7 +352,7 @@ var ContentDecryptor = /** @class */ (function (_super) {
                                             .reduce(function (acc, kid) { return "".concat(acc, ", ").concat(bytesToHex(kid)); }, "");
                                         log.debug("DRM: Blacklisting new key ids", hexKids);
                                     }
-                                    updateDecipherability(initializationData.content.manifest, [], keyIds);
+                                    updateDecipherability(initializationData.content.manifest, [], keyIds, []);
                                 }
                                 return [2 /*return*/];
                             }
@@ -380,7 +381,7 @@ var ContentDecryptor = /** @class */ (function (_super) {
                                                 createdSess.keyStatuses.blacklisted.push(innerKid);
                                             }
                                         }
-                                        updateDecipherability(initializationData.content.manifest, createdSess.keyStatuses.whitelisted, createdSess.keyStatuses.blacklisted);
+                                        updateDecipherability(initializationData.content.manifest, createdSess.keyStatuses.whitelisted, createdSess.keyStatuses.blacklisted, []);
                                         return [2 /*return*/];
                                     }
                                 }
@@ -428,7 +429,7 @@ var ContentDecryptor = /** @class */ (function (_super) {
                                         _this.trigger("warning", evt.value);
                                         return;
                                 }
-                                var linkedKeys = getKeyIdsLinkedToSession(initializationData, sessionInfo.record, options.singleLicensePer, sessionInfo.source === "created-session" /* MediaKeySessionLoadingType.Created */, evt.value.whitelistedKeyIds, evt.value.blacklistedKeyIDs);
+                                var linkedKeys = getKeyIdsLinkedToSession(initializationData, sessionInfo.record, options.singleLicensePer, sessionInfo.source === "created-session" /* MediaKeySessionLoadingType.Created */, evt.value.whitelistedKeyIds, evt.value.blacklistedKeyIds);
                                 sessionInfo.record.associateKeyIds(linkedKeys.whitelisted);
                                 sessionInfo.record.associateKeyIds(linkedKeys.blacklisted);
                                 sessionInfo.keyStatuses = { whitelisted: linkedKeys.whitelisted,
@@ -443,11 +444,36 @@ var ContentDecryptor = /** @class */ (function (_super) {
                                     isSessionPersisted = true;
                                 }
                                 if (initializationData.content !== undefined) {
-                                    updateDecipherability(initializationData.content.manifest, linkedKeys.whitelisted, linkedKeys.blacklisted);
+                                    updateDecipherability(initializationData.content.manifest, linkedKeys.whitelisted, linkedKeys.blacklisted, []);
                                 }
                                 _this._unlockInitDataQueue();
                             },
                             error: function (err) {
+                                var _a;
+                                if (err instanceof DecommissionedSessionError) {
+                                    log.warn("DRM: A session's closing condition has been triggered");
+                                    _this._lockInitDataQueue();
+                                    var indexOf = _this._currentSessions.indexOf(sessionInfo);
+                                    if (indexOf >= 0) {
+                                        _this._currentSessions.splice(indexOf);
+                                    }
+                                    if (initializationData.content !== undefined) {
+                                        updateDecipherability(initializationData.content.manifest, [], [], sessionInfo.record.getAssociatedKeyIds());
+                                    }
+                                    (_a = stores.persistentSessionsStore) === null || _a === void 0 ? void 0 : _a.delete(mediaKeySession.sessionId);
+                                    stores.loadedSessionsStore.closeSession(mediaKeySession)
+                                        .catch(function (e) {
+                                        var closeError = e instanceof Error ? e :
+                                            "unknown error";
+                                        log.warn("DRM: failed to close expired session", closeError);
+                                    })
+                                        .then(function () { return _this._unlockInitDataQueue(); })
+                                        .catch(function (retryError) { return _this._onFatalError(retryError); });
+                                    if (!_this._isStopped()) {
+                                        _this.trigger("warning", err.reason);
+                                    }
+                                    return;
+                                }
                                 if (!(err instanceof BlacklistedSessionError)) {
                                     _this._onFatalError(err);
                                     return;
@@ -559,7 +585,7 @@ var ContentDecryptor = /** @class */ (function (_super) {
                 }
                 log.info("DRM: Current initialization data is linked to blacklisted keys. " +
                     "Marking Representations as not decipherable");
-                updateDecipherability(initializationData.content.manifest, [], initializationData.keyIds);
+                updateDecipherability(initializationData.content.manifest, [], initializationData.keyIds, []);
                 return true;
             }
         }
@@ -586,13 +612,23 @@ var ContentDecryptor = /** @class */ (function (_super) {
         }
         return false;
     };
+    /**
+     * Callback that should be called if an error that made the current
+     * `ContentDecryptor` instance unusable arised.
+     * This callbacks takes care of resetting state and sending the right events.
+     *
+     * Once called, no further actions should be taken.
+     *
+     * @param {*} err - The error object which describes the issue. Will be
+     * formatted and sent in an "error" event.
+     */
     ContentDecryptor.prototype._onFatalError = function (err) {
         if (this._canceller.isUsed) {
             return;
         }
         var formattedErr = err instanceof Error ?
             err :
-            new OtherError("NONE", "Unknown encryption error");
+            new OtherError("NONE", "Unknown decryption error");
         this.error = formattedErr;
         this._initDataQueue.length = 0;
         this._stateData = { state: ContentDecryptorState.Error,
@@ -615,6 +651,10 @@ var ContentDecryptor = /** @class */ (function (_super) {
         return this._stateData.state === ContentDecryptorState.Disposed ||
             this._stateData.state === ContentDecryptorState.Error;
     };
+    /**
+     * Start processing the next initialization data of the `_initDataQueue` if it
+     * isn't lock.
+     */
     ContentDecryptor.prototype._processCurrentInitDataQueue = function () {
         while (this._stateData.isInitDataQueueLocked === false) {
             var initData = this._initDataQueue.shift();
@@ -624,11 +664,23 @@ var ContentDecryptor = /** @class */ (function (_super) {
             this.onInitializationData(initData);
         }
     };
+    /**
+     * Lock new initialization data (from the `_initDataQueue`) from being
+     * processed until `_unlockInitDataQueue` is called.
+     *
+     * You may want to call this method when performing operations which may have
+     * an impact on the handling of other initialization data.
+     */
     ContentDecryptor.prototype._lockInitDataQueue = function () {
         if (this._stateData.isInitDataQueueLocked === false) {
             this._stateData.isInitDataQueueLocked = true;
         }
     };
+    /**
+     * Unlock `_initDataQueue` and start processing the first element.
+     *
+     * Should have no effect if the `_initDataQueue` was not locked.
+     */
     ContentDecryptor.prototype._unlockInitDataQueue = function () {
         if (this._stateData.isMediaKeysAttached !== true) {
             log.error("DRM: Trying to unlock in the wrong state");
@@ -651,7 +703,25 @@ function canCreatePersistentSession(mediaKeySystemAccess) {
     return sessionTypes !== undefined &&
         arrayIncludes(sessionTypes, "persistent-license");
 }
-function updateDecipherability(manifest, whitelistedKeyIds, blacklistedKeyIDs) {
+/**
+ * Change the decipherability of Representations which have their key id in one
+ * of the given Arrays:
+ *
+ *   - Those who have a key id listed in `whitelistedKeyIds` will have their
+ *     decipherability updated to `true`
+ *
+ *   - Those who have a key id listed in `blacklistedKeyIds` will have their
+ *     decipherability updated to `false`
+ *
+ *   - Those who have a key id listed in `delistedKeyIds` will have their
+ *     decipherability updated to `undefined`.
+ *
+ * @param {Object} manifest
+ * @param {Array.<Uint8Array>} whitelistedKeyIds
+ * @param {Array.<Uint8Array>} blacklistedKeyIds
+ * @param {Array.<Uint8Array>} delistedKeyIds
+ */
+function updateDecipherability(manifest, whitelistedKeyIds, blacklistedKeyIds, delistedKeyIds) {
     manifest.updateRepresentationsDeciperability(function (representation) {
         if (representation.contentProtections === undefined) {
             return representation.decipherable;
@@ -660,8 +730,8 @@ function updateDecipherability(manifest, whitelistedKeyIds, blacklistedKeyIDs) {
         if (contentKIDs !== undefined) {
             for (var i = 0; i < contentKIDs.length; i++) {
                 var elt = contentKIDs[i];
-                for (var j = 0; j < blacklistedKeyIDs.length; j++) {
-                    if (areKeyIdsEqual(blacklistedKeyIDs[j], elt.keyId)) {
+                for (var j = 0; j < blacklistedKeyIds.length; j++) {
+                    if (areKeyIdsEqual(blacklistedKeyIds[j], elt.keyId)) {
                         return false;
                     }
                 }
@@ -670,11 +740,22 @@ function updateDecipherability(manifest, whitelistedKeyIds, blacklistedKeyIDs) {
                         return true;
                     }
                 }
+                for (var j = 0; j < delistedKeyIds.length; j++) {
+                    if (areKeyIdsEqual(delistedKeyIds[j], elt.keyId)) {
+                        return undefined;
+                    }
+                }
             }
         }
         return representation.decipherable;
     });
 }
+/**
+ * Update decipherability to `false` to any Representation which is linked to
+ * the given initialization data.
+ * @param {Object} manifest
+ * @param {Object} initData
+ */
 function blackListProtectionData(manifest, initData) {
     manifest.updateRepresentationsDeciperability(function (representation) {
         var _a, _b;
@@ -874,6 +955,12 @@ function getKeyIdsLinkedToSession(initializationData, keySessionRecord, singleLi
         /** associatedKeyIds starts with the whitelisted one. */
         blacklisted: associatedKeyIds.slice(usableKeyIds.length) };
 }
+/**
+ * Push all kei ids in the given `set` and add it to the `arr` Array only if it
+ * isn't already present in it.
+ * @param {Set.<Uint8Array>} set
+ * @param {Array.<Uint8Array>} arr
+ */
 function mergeKeyIdSetIntoArray(set, arr) {
     var setArr = Array.from(set.values());
     var _loop_4 = function (kid) {
@@ -887,6 +974,11 @@ function mergeKeyIdSetIntoArray(set, arr) {
         _loop_4(kid);
     }
 }
+/**
+ * Add to the given `set` all key ids found in the given `Period`.
+ * @param {Set.<Uint8Array>} set
+ * @param {Object} period
+ */
 function addKeyIdsFromPeriod(set, period) {
     for (var _i = 0, _a = period.getAdaptations(); _i < _a.length; _i++) {
         var adaptation = _a[_i];