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

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

@@ -87,7 +87,7 @@ export default function attachMediaKeys(mediaElement, _a, cancelSignal) {
                     _b.sent();
                     // If this task has been cancelled while we were closing previous sessions,
                     // stop now (and thus avoid setting the new media keys);
-                    if (cancelSignal.isCancelled) {
+                    if (cancelSignal.isCancelled()) {
                         throw cancelSignal.cancellationError;
                     }
                     MediaKeysInfosStore.setState(mediaElement, { keySystemOptions: keySystemOptions, mediaKeySystemAccess: mediaKeySystemAccess, mediaKeys: mediaKeys, loadedSessionsStore: loadedSessionsStore });

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

@@ -614,7 +614,7 @@ var ContentDecryptor = /** @class */ (function (_super) {
      * formatted and sent in an "error" event.
      */
     ContentDecryptor.prototype._onFatalError = function (err) {
-        if (this._canceller.isUsed) {
+        if (this._canceller.isUsed()) {
             return;
         }
         var formattedErr = err instanceof Error ?

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

@@ -13,6 +13,17 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -127,7 +138,7 @@ function buildKeySystemConfigurations(keySystemTypeInfo) {
     if (!isNullOrUndefined(keySystem.distinctiveIdentifier)) {
         distinctiveIdentifier = keySystem.distinctiveIdentifier;
     }
-    var _a = config.getCurrent(), EME_DEFAULT_WIDEVINE_ROBUSTNESSES = _a.EME_DEFAULT_WIDEVINE_ROBUSTNESSES, EME_DEFAULT_PLAYREADY_RECOMMENDATION_ROBUSTNESSES = _a.EME_DEFAULT_PLAYREADY_RECOMMENDATION_ROBUSTNESSES;
+    var _a = config.getCurrent(), EME_DEFAULT_AUDIO_CODECS = _a.EME_DEFAULT_AUDIO_CODECS, EME_DEFAULT_VIDEO_CODECS = _a.EME_DEFAULT_VIDEO_CODECS, EME_DEFAULT_WIDEVINE_ROBUSTNESSES = _a.EME_DEFAULT_WIDEVINE_ROBUSTNESSES, EME_DEFAULT_PLAYREADY_RECOMMENDATION_ROBUSTNESSES = _a.EME_DEFAULT_PLAYREADY_RECOMMENDATION_ROBUSTNESSES;
     // From the W3 EME spec, we have to provide videoCapabilities and
     // audioCapabilities.
     // These capabilities must specify a codec (even though you can use a
@@ -164,7 +175,7 @@ function buildKeySystemConfigurations(keySystemTypeInfo) {
         }
         var audioCodecs_1 = (audioCapabilitiesConfig === null || audioCapabilitiesConfig === void 0 ? void 0 : audioCapabilitiesConfig.type) === "contentType" ?
             audioCapabilitiesConfig.value :
-            ["audio/mp4;codecs=\"mp4a.40.2\"", "audio/webm;codecs=opus"];
+            EME_DEFAULT_AUDIO_CODECS;
         audioCapabilities = flatMap(audioRobustnesses, function (robustness) {
             return audioCodecs_1.map(function (contentType) {
                 return robustness !== undefined ? { contentType: contentType, robustness: robustness } :
@@ -194,9 +205,7 @@ function buildKeySystemConfigurations(keySystemTypeInfo) {
         }
         var videoCodecs_1 = (videoCapabilitiesConfig === null || videoCapabilitiesConfig === void 0 ? void 0 : videoCapabilitiesConfig.type) === "contentType" ?
             videoCapabilitiesConfig.value :
-            ["video/mp4;codecs=\"avc1.4d401e\"",
-                "video/mp4;codecs=\"avc1.42e01e\"",
-                "video/webm;codecs=\"vp8\""];
+            EME_DEFAULT_VIDEO_CODECS;
         videoCapabilities = flatMap(videoRobustnesses, function (robustness) {
             return videoCodecs_1.map(function (contentType) {
                 return robustness !== undefined ? { contentType: contentType, robustness: robustness } :
@@ -204,7 +213,21 @@ function buildKeySystemConfigurations(keySystemTypeInfo) {
             });
         });
     }
-    return [{ initDataTypes: ["cenc"], videoCapabilities: videoCapabilities, audioCapabilities: audioCapabilities, distinctiveIdentifier: distinctiveIdentifier, persistentState: persistentState, sessionTypes: sessionTypes }];
+    var wantedMediaKeySystemConfiguration = {
+        initDataTypes: ["cenc"],
+        videoCapabilities: videoCapabilities,
+        audioCapabilities: audioCapabilities,
+        distinctiveIdentifier: distinctiveIdentifier,
+        persistentState: persistentState,
+        sessionTypes: sessionTypes,
+    };
+    return [
+        wantedMediaKeySystemConfiguration,
+        // Some legacy implementations have issues with `audioCapabilities` and
+        // `videoCapabilities`, so we're including a supplementary
+        // `MediaKeySystemConfiguration` without those properties.
+        __assign(__assign({}, wantedMediaKeySystemConfiguration), { audioCapabilities: undefined, videoCapabilities: undefined }),
+    ];
 }
 /**
  * Try to find a compatible key system from the keySystems array given.

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

@@ -86,12 +86,13 @@ export default function SessionEventsListener(session, keySystemOptions, keySyst
     log.info("DRM: Binding session events", session.sessionId);
     var _a = keySystemOptions.getLicenseConfig, getLicenseConfig = _a === void 0 ? {} : _a;
     /** Allows to manually cancel everything the `SessionEventsListener` is doing. */
-    var manualCanceller = new TaskCanceller({ cancelOn: cancelSignal });
+    var manualCanceller = new TaskCanceller();
+    manualCanceller.linkToSignal(cancelSignal);
     if (!isNullOrUndefined(session.closed)) {
         session.closed
             .then(function () { return manualCanceller.cancel(); })
             .catch(function (err) {
-            if (cancelSignal.isCancelled) {
+            if (cancelSignal.isCancelled()) {
                 return;
             }
             manualCanceller.cancel();
@@ -104,11 +105,11 @@ export default function SessionEventsListener(session, keySystemOptions, keySyst
     }, manualCanceller.signal);
     onKeyStatusesChange(session, function () {
         try {
-            handleKeyStatusesChangeEvent();
+            checkAndHandleCurrentKeyStatuses();
         }
         catch (error) {
-            if (cancelSignal.isCancelled ||
-                (manualCanceller.isUsed && error instanceof CancellationSignal)) {
+            if (cancelSignal.isCancelled() ||
+                (manualCanceller.isUsed() && error instanceof CancellationSignal)) {
                 return;
             }
             manualCanceller.cancel();
@@ -125,18 +126,24 @@ export default function SessionEventsListener(session, keySystemOptions, keySyst
         var backoffOptions = getLicenseBackoffOptions(getLicenseConfig.retry);
         retryPromiseWithBackoff(function () { return runGetLicense(message, messageType); }, backoffOptions, manualCanceller.signal)
             .then(function (licenseObject) {
-            if (manualCanceller.isUsed) {
+            if (manualCanceller.isUsed()) {
                 return Promise.resolve();
             }
             if (isNullOrUndefined(licenseObject)) {
                 log.info("DRM: No license given, skipping session.update");
             }
             else {
-                return updateSessionWithMessage(session, licenseObject);
+                try {
+                    return updateSessionWithMessage(session, licenseObject);
+                }
+                catch (err) {
+                    manualCanceller.cancel();
+                    callbacks.onError(err);
+                }
             }
         })
             .catch(function (err) {
-            if (manualCanceller.isUsed) {
+            if (manualCanceller.isUsed()) {
                 return;
             }
             manualCanceller.cancel();
@@ -153,56 +160,59 @@ export default function SessionEventsListener(session, keySystemOptions, keySyst
             callbacks.onError(formattedError);
         });
     }, manualCanceller.signal);
+    checkAndHandleCurrentKeyStatuses();
+    return;
     /**
      * Check current MediaKeyStatus for each key in the given MediaKeySession and:
      *   - throw if at least one status is a non-recoverable error
      *   - call warning callback for recoverable errors
      *   - call onKeyUpdate callback when the MediaKeyStatus of any key is updated
      */
-    function handleKeyStatusesChangeEvent() {
+    function checkAndHandleCurrentKeyStatuses() {
         log.info("DRM: keystatuseschange event received", session.sessionId);
-        if (manualCanceller.isUsed || session.keyStatuses.size === 0) {
+        if (manualCanceller.isUsed() || session.keyStatuses.size === 0) {
             return;
         }
         var _a = checkKeyStatuses(session, keySystemOptions, keySystem), warning = _a.warning, blacklistedKeyIds = _a.blacklistedKeyIds, whitelistedKeyIds = _a.whitelistedKeyIds;
         if (warning !== undefined) {
             callbacks.onWarning(warning);
-            if (manualCanceller.isUsed) {
+            if (manualCanceller.isUsed()) {
                 return;
             }
         }
         callbacks.onKeyUpdate({ whitelistedKeyIds: whitelistedKeyIds, blacklistedKeyIds: blacklistedKeyIds });
     }
     function runGetLicense(message, messageType) {
+        var timeoutId;
         return new Promise(function (res, rej) {
-            log.debug("DRM: Calling `getLicense`", messageType);
-            var getLicense = keySystemOptions.getLicense(message, messageType);
-            var getLicenseTimeout = isNullOrUndefined(getLicenseConfig.timeout) ?
-                10 * 1000 :
-                getLicenseConfig.timeout;
-            var timeoutId;
-            if (getLicenseTimeout >= 0) {
-                timeoutId = setTimeout(function () {
-                    rej(new GetLicenseTimeoutError("\"getLicense\" timeout exceeded (".concat(getLicenseTimeout, " ms)")));
-                }, getLicenseTimeout);
-            }
             try {
-                Promise.resolve(getLicense).then(function (val) {
-                    clearTimeoutIfOne();
-                    res(val);
-                }, function (err) {
-                    clearTimeoutIfOne();
-                    rej(err);
-                });
+                log.debug("DRM: Calling `getLicense`", messageType);
+                var getLicense = keySystemOptions.getLicense(message, messageType);
+                var getLicenseTimeout_1 = isNullOrUndefined(getLicenseConfig.timeout) ?
+                    10 * 1000 :
+                    getLicenseConfig.timeout;
+                if (getLicenseTimeout_1 >= 0) {
+                    timeoutId = setTimeout(function () {
+                        rej(new GetLicenseTimeoutError("\"getLicense\" timeout exceeded (".concat(getLicenseTimeout_1, " ms)")));
+                    }, getLicenseTimeout_1);
+                }
+                Promise.resolve(getLicense)
+                    .then(clearTimeoutAndResolve, clearTimeoutAndReject);
             }
             catch (err) {
-                clearTimeoutIfOne();
-                rej(err);
+                clearTimeoutAndReject(err);
             }
-            function clearTimeoutIfOne() {
+            function clearTimeoutAndResolve(data) {
                 if (timeoutId !== undefined) {
                     clearTimeout(timeoutId);
                 }
+                res(data);
+            }
+            function clearTimeoutAndReject(err) {
+                if (timeoutId !== undefined) {
+                    clearTimeout(timeoutId);
+                }
+                rej(err);
             }
         });
     }

package/dist/_esm5.processed/core/decrypt/utils/check_key_statuses.js

@@ -40,6 +40,7 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
 /* eslint-disable-next-line max-len */
 import getUUIDKidFromKeyStatusKID from "../../../compat/eme/get_uuid_kid_from_keystatus_kid";
 import { EncryptedMediaError } from "../../../errors";
+import log from "../../../log";
 import assertUnreachable from "../../../utils/assert_unreachable";
 import { bytesToHex } from "../../../utils/string_parsing";
 /**
@@ -95,6 +96,9 @@ export default function checkKeyStatuses(session, options, keySystem) {
         })(), keyStatus = _a[0], keyStatusKeyId = _a[1];
         var keyId = getUUIDKidFromKeyStatusKID(keySystem, new Uint8Array(keyStatusKeyId));
         var keyStatusObj = { keyId: keyId.buffer, keyStatus: keyStatus };
+        if (log.hasLevel("DEBUG")) {
+            log.debug("DRM: key status update (".concat(bytesToHex(keyId), "): ").concat(keyStatus));
+        }
         switch (keyStatus) {
             case KEY_STATUSES.EXPIRED: {
                 var error = new EncryptedMediaError("KEY_STATUS_CHANGE_ERROR", "A decryption key expired (".concat(bytesToHex(keyId), ")"), { keyStatuses: __spreadArray([keyStatusObj], badKeyStatuses, true) });

package/dist/_esm5.processed/core/decrypt/utils/clean_old_loaded_sessions.js

@@ -49,6 +49,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
         if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
     }
 };
+import log from "../../../log";
 /**
  * Close sessions from the loadedSessionsStore to allow at maximum `limit`
  * stored MediaKeySessions in it.
@@ -67,6 +68,7 @@ export default function cleanOldLoadedSessions(loadedSessionsStore, limit) {
                     if (limit < 0 || limit >= loadedSessionsStore.getLength()) {
                         return [2 /*return*/];
                     }
+                    log.info("DRM: LSS cache limit exceeded", limit, loadedSessionsStore.getLength());
                     proms = [];
                     entries = loadedSessionsStore.getAll().slice();
                     toDelete = entries.length - limit;

package/dist/_esm5.processed/core/decrypt/utils/loaded_sessions_store.js

@@ -92,6 +92,7 @@ var LoadedSessionsStore = /** @class */ (function () {
     LoadedSessionsStore.prototype.createSession = function (initData, sessionType) {
         var _this = this;
         var keySessionRecord = new KeySessionRecord(initData);
+        log.debug("DRM-LSS: calling `createSession`", sessionType);
         var mediaKeySession = this._mediaKeys.createSession(sessionType);
         var entry = { mediaKeySession: mediaKeySession, sessionType: sessionType, keySessionRecord: keySessionRecord, isGeneratingRequest: false,
             isLoadingPersistentSession: false,
@@ -99,6 +100,7 @@ var LoadedSessionsStore = /** @class */ (function () {
         if (!isNullOrUndefined(mediaKeySession.closed)) {
             mediaKeySession.closed
                 .then(function () {
+                log.info("DRM-LSS: session was closed, removing it.", mediaKeySession.sessionId);
                 var index = _this.getIndex(keySessionRecord);
                 if (index >= 0 &&
                     _this._storage[index].mediaKeySession === mediaKeySession) {
@@ -110,8 +112,8 @@ var LoadedSessionsStore = /** @class */ (function () {
                 log.warn("DRM-LSS: MediaKeySession.closed rejected: ".concat(e));
             });
         }
-        log.debug("DRM-LSS: Add MediaKeySession", entry.sessionType);
         this._storage.push(__assign({}, entry));
+        log.debug("DRM-LSS: MediaKeySession added", entry.sessionType, this._storage.length);
         return entry;
     };
     /**
@@ -132,6 +134,7 @@ var LoadedSessionsStore = /** @class */ (function () {
             if (stored.keySessionRecord.isCompatibleWith(initializationData)) {
                 this._storage.splice(i, 1);
                 this._storage.push(stored);
+                log.debug("DRM-LSS: Reusing session:", stored.mediaKeySession.sessionId, stored.sessionType);
                 return __assign({}, stored);
             }
         }
@@ -365,6 +368,7 @@ var LoadedSessionsStore = /** @class */ (function () {
         for (var i = this._storage.length - 1; i >= 0; i--) {
             var stored = this._storage[i];
             if (stored.mediaKeySession === mediaKeySession) {
+                log.debug("DRM-LSS: Removing session without closing it", mediaKeySession.sessionId);
                 this._storage.splice(i, 1);
                 return true;
             }

package/dist/_esm5.processed/core/fetchers/cdn_prioritizer.d.ts

@@ -14,17 +14,20 @@
  * limitations under the License.
  */
 import { ICdnMetadata } from "../../parsers/manifest";
-import { IPlayerError } from "../../public_types";
 import EventEmitter from "../../utils/event_emitter";
 import { CancellationSignal } from "../../utils/task_canceller";
 /**
- * Class signaling the priority between multiple CDN available for any given
- * resource.
+ * Class storing and signaling the priority between multiple CDN available for
+ * any given resource.
  *
- * This class might perform requests and schedule timeouts by itself to keep its
- * internal list of CDN priority up-to-date.
- * When it is not needed anymore, you should call the `dispose` method to clear
- * all resources.
+ * This class was first created to implement the complexities behind
+ * Content Steering features, though its handling hasn't been added yet as we
+ * wait for its specification to be both standardized and relied on in the wild.
+ * In the meantime, it acts as an abstraction for the simple concept of
+ * avoiding to request a CDN for any segment when an issue is encountered with
+ * one (e.g. HTTP 500 statuses) and several CDN exist for a given resource. It
+ * should be noted that this is also one of the planified features of the
+ * Content Steering specification.
  *
  * @class CdnPrioritizer
  */
@@ -92,7 +95,13 @@ export default class CdnPrioritizer extends EventEmitter<ICdnPrioritizerEvents>
      */
     private _removeIndexFromDowngradeList;
 }
+/** Events sent by a `CdnPrioritizer` */
 export interface ICdnPrioritizerEvents {
-    warnings: IPlayerError[];
+    /**
+     * The priority of one or several CDN changed.
+     *
+     * You might want to re-check if a CDN should still be used when this event
+     * is triggered.
+     */
     priorityChange: null;
 }

package/dist/_esm5.processed/core/fetchers/cdn_prioritizer.js

@@ -32,13 +32,17 @@ import config from "../../config";
 import arrayFindIndex from "../../utils/array_find_index";
 import EventEmitter from "../../utils/event_emitter";
 /**
- * Class signaling the priority between multiple CDN available for any given
- * resource.
+ * Class storing and signaling the priority between multiple CDN available for
+ * any given resource.
  *
- * This class might perform requests and schedule timeouts by itself to keep its
- * internal list of CDN priority up-to-date.
- * When it is not needed anymore, you should call the `dispose` method to clear
- * all resources.
+ * This class was first created to implement the complexities behind
+ * Content Steering features, though its handling hasn't been added yet as we
+ * wait for its specification to be both standardized and relied on in the wild.
+ * In the meantime, it acts as an abstraction for the simple concept of
+ * avoiding to request a CDN for any segment when an issue is encountered with
+ * one (e.g. HTTP 500 statuses) and several CDN exist for a given resource. It
+ * should be noted that this is also one of the planified features of the
+ * Content Steering specification.
  *
  * @class CdnPrioritizer
  */

package/dist/_esm5.processed/core/fetchers/manifest/manifest_fetcher.js

@@ -144,7 +144,7 @@ var ManifestFetcher = /** @class */ (function (_super) {
         manifestProm
             .then(function (val) {
             _this.trigger("manifestReady", val.manifest);
-            if (!_this._canceller.isUsed) {
+            if (!_this._canceller.isUsed()) {
                 _this._recursivelyRefreshManifest(val.manifest, val);
             }
         })
@@ -293,7 +293,7 @@ var ManifestFetcher = /** @class */ (function (_super) {
             function onWarnings(warnings) {
                 for (var _i = 0, warnings_1 = warnings; _i < warnings_1.length; _i++) {
                     var warning = warnings_1[_i];
-                    if (cancelSignal.isCancelled) {
+                    if (cancelSignal.isCancelled()) {
                         return;
                     }
                     var formattedError = formatError(warning, {
@@ -411,7 +411,8 @@ var ManifestFetcher = /** @class */ (function (_super) {
          * be effectively considered.
          * `nextRefreshCanceller` will allow to cancel every other when one is triggered.
          */
-        var nextRefreshCanceller = new TaskCanceller({ cancelOn: this._canceller.signal });
+        var nextRefreshCanceller = new TaskCanceller();
+        nextRefreshCanceller.linkToSignal(this._canceller.signal);
         /* Function to manually schedule a Manifest refresh */
         this.scheduleManualRefresh = function (settings) {
             var enablePartialRefresh = settings.enablePartialRefresh, delay = settings.delay, canUseUnsafeMode = settings.canUseUnsafeMode;
@@ -584,7 +585,7 @@ var ManifestFetcher = /** @class */ (function (_super) {
         });
     };
     ManifestFetcher.prototype._onFatalError = function (err) {
-        if (this._canceller.isUsed) {
+        if (this._canceller.isUsed()) {
             return;
         }
         this.trigger("error", err);

package/dist/_esm5.processed/core/fetchers/segment/segment_fetcher.d.ts

@@ -26,10 +26,22 @@ import CdnPrioritizer from "../cdn_prioritizer";
  * An `ISegmentFetcher` also implements a retry mechanism, based on the given
  * `options` argument, which may retry a segment request when it fails.
  *
- * @param {string} bufferType
- * @param {Object} pipeline
- * @param {Object} lifecycleCallbacks
- * @param {Object} options
+ * @param {string} bufferType - Type of  buffer concerned (e.g. `"audio"`,
+ * `"video"`, `"text" etc.)
+ * @param {Object} pipeline - The transport-specific logic allowing to load
+ * segments of the given buffer type and transport protocol (e.g. DASH).
+ * @param {Object|null} cdnPrioritizer - Abstraction allowing to synchronize,
+ * update and keep track of the priorization of the CDN to use to load any given
+ * segment, in cases where multiple ones are available.
+ *
+ * Can be set to `null` in which case a minimal priorization logic will be used
+ * instead.
+ * @param {Object} lifecycleCallbacks - Callbacks that can be registered to be
+ * informed when new requests are made, ended, new metrics are available etc.
+ * This should be mainly useful to implement an adaptive logic relying on those
+ * metrics and events.
+ * @param {Object} options - Various tweaking options allowing to configure the
+ * behavior of the returned `ISegmentFetcher`.
  * @returns {Function}
  */
 export default function createSegmentFetcher<TLoadedFormat, TSegmentDataType>(bufferType: IBufferType, pipeline: ISegmentPipeline<TLoadedFormat, TSegmentDataType>, cdnPrioritizer: CdnPrioritizer | null, lifecycleCallbacks: ISegmentFetcherLifecycleCallbacks, options: ISegmentFetcherOptions): ISegmentFetcher<TSegmentDataType>;
@@ -59,10 +71,15 @@ export interface ISegmentFetcherCallbacks<TSegmentDataType> {
     /**
      * Callback called when all decodable chunks of the loaded segment have been
      * communicated through the `onChunk` callback.
+     *
+     * This callback is called before the corresponding `ISegmentFetcher`'s
+     * returned Promise is resolved.
      */
     onAllChunksReceived(): void;
     /**
-     * Callback called when the segment request has to restart from scratch. */
+     * Callback called when the segment request has to restart from scratch, e.g.
+     * due to a request error.
+     */
     onRetry(error: IPlayerError): void;
 }
 /** Content used by the segment loader as a context to load a new segment. */

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

@@ -69,10 +69,22 @@ var generateRequestID = idGenerator();
  * An `ISegmentFetcher` also implements a retry mechanism, based on the given
  * `options` argument, which may retry a segment request when it fails.
  *
- * @param {string} bufferType
- * @param {Object} pipeline
- * @param {Object} lifecycleCallbacks
- * @param {Object} options
+ * @param {string} bufferType - Type of  buffer concerned (e.g. `"audio"`,
+ * `"video"`, `"text" etc.)
+ * @param {Object} pipeline - The transport-specific logic allowing to load
+ * segments of the given buffer type and transport protocol (e.g. DASH).
+ * @param {Object|null} cdnPrioritizer - Abstraction allowing to synchronize,
+ * update and keep track of the priorization of the CDN to use to load any given
+ * segment, in cases where multiple ones are available.
+ *
+ * Can be set to `null` in which case a minimal priorization logic will be used
+ * instead.
+ * @param {Object} lifecycleCallbacks - Callbacks that can be registered to be
+ * informed when new requests are made, ended, new metrics are available etc.
+ * This should be mainly useful to implement an adaptive logic relying on those
+ * metrics and events.
+ * @param {Object} options - Various tweaking options allowing to configure the
+ * behavior of the returned `ISegmentFetcher`.
  * @returns {Function}
  */
 export default function createSegmentFetcher(bufferType, pipeline, cdnPrioritizer, lifecycleCallbacks, options) {
@@ -97,8 +109,17 @@ export default function createSegmentFetcher(bufferType, pipeline, cdnPrioritize
      * @returns {Promise}
      */
     return function fetchSegment(content, fetcherCallbacks, cancellationSignal) {
-        var _a, _b;
+        var _a, _b, _c;
         return __awaiter(this, void 0, void 0, function () {
+            function onCancellation() {
+                var _a;
+                if (requestInfo !== undefined) {
+                    return; // Request already terminated
+                }
+                log.debug("SF: Segment request cancelled", segmentIdString);
+                requestInfo = null;
+                (_a = lifecycleCallbacks.onRequestEnd) === null || _a === void 0 ? void 0 : _a.call(lifecycleCallbacks, { id: requestId });
+            }
             /**
              * Call a segment loader for the given URL with the right arguments.
              * @param {Object|null} cdnMetadata
@@ -169,8 +190,8 @@ export default function createSegmentFetcher(bufferType, pipeline, cdnPrioritize
                 }
             }
             var segment, adaptation, representation, manifest, period, segmentIdString, requestId, requestInfo, parsedChunks, segmentDurationAcc, metricsSent, context, loaderCallbacks, cached, res, loadedData, err_1;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
+            return __generator(this, function (_d) {
+                switch (_d.label) {
                     case 0:
                         segment = content.segment, adaptation = content.adaptation, representation = content.representation, manifest = content.manifest, period = content.period;
                         segmentIdString = getLoggableSegmentId(content);
@@ -225,21 +246,13 @@ export default function createSegmentFetcher(bufferType, pipeline, cdnPrioritize
                         log.debug("SF: Beginning request", segmentIdString);
                         (_a = lifecycleCallbacks.onRequestBegin) === null || _a === void 0 ? void 0 : _a.call(lifecycleCallbacks, { requestTimestamp: performance.now(),
                             id: requestId, content: content });
-                        cancellationSignal.register(function () {
-                            var _a;
-                            if (requestInfo !== undefined) {
-                                return; // Request already terminated
-                            }
-                            log.debug("SF: Segment request cancelled", segmentIdString);
-                            requestInfo = null;
-                            (_a = lifecycleCallbacks.onRequestEnd) === null || _a === void 0 ? void 0 : _a.call(lifecycleCallbacks, { id: requestId });
-                        });
-                        _c.label = 1;
+                        cancellationSignal.register(onCancellation);
+                        _d.label = 1;
                     case 1:
-                        _c.trys.push([1, 3, , 4]);
+                        _d.trys.push([1, 3, , 4]);
                         return [4 /*yield*/, scheduleRequestWithCdns(content.representation.cdnMetadata, cdnPrioritizer, callLoaderWithUrl, objectAssign({ onRetry: onRetry }, options), cancellationSignal)];
                     case 2:
-                        res = _c.sent();
+                        res = _d.sent();
                         if (res.resultType === "segment-loaded") {
                             loadedData = res.resultData.responseData;
                             if (cache !== undefined) {
@@ -259,21 +272,24 @@ export default function createSegmentFetcher(bufferType, pipeline, cdnPrioritize
                         else {
                             requestInfo = null;
                         }
-                        if (!cancellationSignal.isCancelled) {
+                        if (!cancellationSignal.isCancelled()) {
                             // The current task could have been canceled as a result of one
                             // of the previous callbacks call. In that case, we don't want to send
                             // a "requestEnd" again as it has already been sent on cancellation.
                             (_b = lifecycleCallbacks.onRequestEnd) === null || _b === void 0 ? void 0 : _b.call(lifecycleCallbacks, { id: requestId });
                         }
+                        cancellationSignal.deregister(onCancellation);
                         return [3 /*break*/, 4];
                     case 3:
-                        err_1 = _c.sent();
+                        err_1 = _d.sent();
+                        cancellationSignal.deregister(onCancellation);
                         requestInfo = null;
                         if (err_1 instanceof CancellationError) {
                             log.debug("SF: Segment request aborted", segmentIdString);
                             throw err_1;
                         }
                         log.debug("SF: Segment request failed", segmentIdString);
+                        (_c = lifecycleCallbacks.onRequestEnd) === null || _c === void 0 ? void 0 : _c.call(lifecycleCallbacks, { id: requestId });
                         throw errorSelector(err_1);
                     case 4: return [2 /*return*/];
                 }