rx-player 3.29.0-dev.2022091600 → 3.29.0-dev.2022103100

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

@@ -43,7 +43,7 @@ var __assign = (this && this.__assign) || function () {
  * This file defines the public API for the RxPlayer.
  * It also starts the different sub-parts of the player on various API calls.
  */
-import { combineLatest as observableCombineLatest, concat as observableConcat, connectable, distinctUntilChanged, EMPTY, filter, map, merge as observableMerge, mergeMap, Observable, of as observableOf, share, shareReplay, skipWhile, startWith, Subject, switchMap, take, takeUntil, } from "rxjs";
+import { combineLatest as observableCombineLatest, concat as observableConcat, connectable, distinctUntilChanged, EMPTY, filter, map, merge as observableMerge, mergeMap, Observable, of as observableOf, share, shareReplay, skipWhile, startWith, Subject, switchMap, take, takeUntil, tap, } from "rxjs";
 import { events, exitFullscreen, getStartDate, isFullscreen, requestFullscreen, } from "../../compat";
 /* eslint-disable-next-line max-len */
 import canRelyOnVideoVisibilityAndSize from "../../compat/can_rely_on_video_visibility_and_size";
@@ -61,7 +61,7 @@ import createSharedReference, { createMappedReference, } from "../../utils/refer
 import TaskCanceller from "../../utils/task_canceller";
 import warnOnce from "../../utils/warn_once";
 import { clearOnStop, disposeDecryptionResources, getCurrentKeySystem, } from "../decrypt";
-import { ManifestFetcher, SegmentFetcherCreator, } from "../fetchers";
+import { ManifestFetcher, } from "../fetchers";
 import initializeMediaSourcePlayback from "../init";
 import { checkReloadOptions, parseConstructorOptions, parseLoadVideoOptions, } from "./option_utils";
 import PlaybackObserver from "./playback_observer";
@@ -87,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.2022091600";
+        _this.version = /* PLAYER_VERSION */ "3.29.0-dev.2022103100";
         _this.log = log;
         _this.state = "STOPPED";
         _this.videoElement = videoElement;
@@ -163,7 +163,7 @@ var Player = /** @class */ (function (_super) {
         _this._priv_preferredAudioTracks = preferredAudioTracks;
         _this._priv_preferredTextTracks = preferredTextTracks;
         _this._priv_preferredVideoTracks = preferredVideoTracks;
-        _this._priv_lastContentPlaybackInfos = {};
+        _this._priv_reloadingMetadata = {};
         return _this;
     }
     Object.defineProperty(Player, "ErrorTypes", {
@@ -262,7 +262,7 @@ var Player = /** @class */ (function (_super) {
         this._priv_bitrateInfos.minAutoBitrates.audio.finish();
         this._priv_bitrateInfos.maxAutoBitrates.video.finish();
         this._priv_bitrateInfos.maxAutoBitrates.audio.finish();
-        this._priv_lastContentPlaybackInfos = {};
+        this._priv_reloadingMetadata = {};
         // un-attach video element
         this.videoElement = null;
     };
@@ -273,50 +273,49 @@ var Player = /** @class */ (function (_super) {
     Player.prototype.loadVideo = function (opts) {
         var options = parseLoadVideoOptions(opts);
         log.info("API: Calling loadvideo", options.url, options.transport);
-        this._priv_lastContentPlaybackInfos = { options: options };
+        this._priv_reloadingMetadata = { options: options };
         this._priv_initializeContentPlayback(options);
     };
     /**
-     * Reload last content. Init media playback without fetching again
-     * the manifest.
+     * Reload the last loaded content.
      * @param {Object} reloadOpts
      */
     Player.prototype.reload = function (reloadOpts) {
-        var _a = this._priv_lastContentPlaybackInfos, options = _a.options, manifest = _a.manifest, lastPlaybackPosition = _a.lastPlaybackPosition;
-        if (options === undefined ||
-            manifest === undefined ||
-            lastPlaybackPosition === undefined) {
+        var _a, _b;
+        var _c = this._priv_reloadingMetadata, options = _c.options, manifest = _c.manifest, reloadPosition = _c.reloadPosition, reloadInPause = _c.reloadInPause;
+        if (options === undefined) {
             throw new Error("API: Can't reload without having previously loaded a content.");
         }
         checkReloadOptions(reloadOpts);
-        var startAtPositon;
-        if (reloadOpts !== undefined &&
-            reloadOpts.reloadAt !== undefined &&
-            reloadOpts.reloadAt.position !== undefined) {
-            startAtPositon = reloadOpts.reloadAt.position;
+        var startAt;
+        if (((_a = reloadOpts === null || reloadOpts === void 0 ? void 0 : reloadOpts.reloadAt) === null || _a === void 0 ? void 0 : _a.position) !== undefined) {
+            startAt = { position: reloadOpts.reloadAt.position };
         }
-        else {
-            var playbackPosition = void 0;
-            if (this.state === "STOPPED" || this.state === "ENDED") {
-                playbackPosition = lastPlaybackPosition;
-            }
-            else {
-                if (this.videoElement === null) {
-                    throw new Error("Can't reload when video element does not exist.");
-                }
-                playbackPosition = this.videoElement.currentTime;
-            }
-            if (reloadOpts !== undefined &&
-                reloadOpts.reloadAt !== undefined &&
-                reloadOpts.reloadAt.relative !== undefined) {
-                startAtPositon = reloadOpts.reloadAt.relative + playbackPosition;
+        else if (((_b = reloadOpts === null || reloadOpts === void 0 ? void 0 : reloadOpts.reloadAt) === null || _b === void 0 ? void 0 : _b.relative) !== undefined) {
+            if (reloadPosition === undefined) {
+                throw new Error("Can't reload to a relative position when previous content was not loaded.");
             }
             else {
-                startAtPositon = playbackPosition;
+                startAt = { position: reloadOpts.reloadAt.relative + reloadPosition };
             }
         }
+        else if (reloadPosition !== undefined) {
+            startAt = { position: reloadPosition };
+        }
+        var autoPlay;
+        if ((reloadOpts === null || reloadOpts === void 0 ? void 0 : reloadOpts.autoPlay) !== undefined) {
+            autoPlay = reloadOpts.autoPlay;
+        }
+        else if (reloadInPause !== undefined) {
+            autoPlay = !reloadInPause;
+        }
         var newOptions = __assign(__assign({}, options), { initialManifest: manifest });
-        newOptions.startAt = { position: startAtPositon };
+        if (startAt !== undefined) {
+            newOptions.startAt = startAt;
+        }
+        if (autoPlay !== undefined) {
+            newOptions.autoPlay = autoPlay;
+        }
         this._priv_initializeContentPlayback(newOptions);
     };
     /**
@@ -377,10 +376,6 @@ var Player = /** @class */ (function (_super) {
             var manifestFetcher = new ManifestFetcher(url, transportPipelines, { lowLatencyMode: lowLatencyMode, maxRetryRegular: manifestRetry,
                 maxRetryOffline: offlineRetry,
                 requestTimeout: manifestRequestTimeout });
-            /** Interface used to download segments. */
-            var segmentFetcherCreator = new SegmentFetcherCreator(transportPipelines, { lowLatencyMode: lowLatencyMode, maxRetryOffline: offlineRetry,
-                maxRetryRegular: segmentRetry,
-                requestTimeout: segmentRequestTimeout });
             /** Observable emitting the initial Manifest */
             var manifest$ = void 0;
             if (initialManifest instanceof Manifest) {
@@ -459,8 +454,11 @@ var Player = /** @class */ (function (_super) {
                 { textTrackMode: "html",
                     textTrackElement: options.textTrackElement };
             var bufferOptions = objectAssign({ audioTrackSwitchingMode: audioTrackSwitchingMode, enableFastSwitching: enableFastSwitching, manualBitrateSwitchingMode: manualBitrateSwitchingMode, onCodecSwitch: onCodecSwitch }, this._priv_bufferOptions);
+            var segmentRequestOptions = { regularError: segmentRetry,
+                requestTimeout: segmentRequestTimeout,
+                offlineError: offlineRetry };
             // We've every options set up. Start everything now
-            var init$ = initializeMediaSourcePlayback({ adaptiveOptions: adaptiveOptions, autoPlay: autoPlay, bufferOptions: bufferOptions, playbackObserver: playbackObserver, keySystems: keySystems, lowLatencyMode: lowLatencyMode, manifest$: manifest$, manifestFetcher: manifestFetcher, mediaElement: videoElement, minimumManifestUpdateInterval: minimumManifestUpdateInterval, segmentFetcherCreator: segmentFetcherCreator, speed: this._priv_speed, startAt: startAt, textTrackOptions: textTrackOptions })
+            var init$ = initializeMediaSourcePlayback({ adaptiveOptions: adaptiveOptions, autoPlay: autoPlay, bufferOptions: bufferOptions, playbackObserver: playbackObserver, keySystems: keySystems, lowLatencyMode: lowLatencyMode, manifest$: manifest$, manifestFetcher: manifestFetcher, mediaElement: videoElement, minimumManifestUpdateInterval: minimumManifestUpdateInterval, segmentRequestOptions: segmentRequestOptions, speed: this._priv_speed, startAt: startAt, transport: transportPipelines, textTrackOptions: textTrackOptions })
                 .pipe(takeUntil(stoppedContent$));
             playback$ = connectable(init$, { connector: function () { return new Subject(); },
                 resetOnDisconnect: false });
@@ -576,25 +574,47 @@ var Player = /** @class */ (function (_super) {
                 playbackSubscription.unsubscribe();
             }
         });
-        // Link "positionUpdate" events to the PlaybackObserver
-        observation$
-            .pipe(takeUntil(stoppedContent$))
-            .subscribe(function (o) { return _this._priv_triggerPositionUpdate(o); });
-        // Link "seeking" and "seeked" events (once the content is loaded)
-        loaded$.pipe(switchMap(function () { return emitSeekEvents(_this.videoElement, observation$); }), takeUntil(stoppedContent$)).subscribe(function (evt) {
-            log.info("API: Triggering \"".concat(evt, "\" event"));
-            _this.trigger(evt, null);
-        });
-        // Handle state updates
-        playerState$
-            .pipe(takeUntil(stoppedContent$))
-            .subscribe(function (newState) {
+        /**
+         * Function updating `this._priv_reloadingMetadata` in function of the
+         * current state and playback conditions.
+         * To call when either might change.
+         * @param {string} state - The player state we're about to switch to.
+         */
+        var updateReloadingMetadata = function (state) {
+            switch (state) {
+                case "STOPPED":
+                case "RELOADING":
+                case "LOADING":
+                    break; // keep previous metadata
+                case "ENDED":
+                    _this._priv_reloadingMetadata.reloadInPause = true;
+                    _this._priv_reloadingMetadata.reloadPosition =
+                        playbackObserver.getReference().getValue().position;
+                    break;
+                default:
+                    var o = playbackObserver.getReference().getValue();
+                    _this._priv_reloadingMetadata.reloadInPause = o.paused;
+                    _this._priv_reloadingMetadata.reloadPosition = o.position;
+                    break;
+            }
+        };
+        playerState$.pipe(tap(function (newState) {
+            updateReloadingMetadata(newState);
             _this._priv_setPlayerState(newState);
             // Previous call could have performed all kind of side-effects, thus,
             // we re-check the current state associated to the RxPlayer
             if (_this.state === "ENDED" && _this._priv_stopAtEnd) {
                 currentContentCanceller.cancel();
             }
+        }), map(function (state) { return state !== "RELOADING" && state !== "STOPPED"; }), distinctUntilChanged(), switchMap(function (canSendObservation) { return canSendObservation ? observation$ :
+            EMPTY; }), takeUntil(stoppedContent$)).subscribe(function (o) {
+            updateReloadingMetadata(_this.state);
+            _this._priv_triggerPositionUpdate(o);
+        });
+        // Link "seeking" and "seeked" events (once the content is loaded)
+        loaded$.pipe(switchMap(function () { return emitSeekEvents(_this.videoElement, observation$); }), takeUntil(stoppedContent$)).subscribe(function (evt) {
+            log.info("API: Triggering \"".concat(evt, "\" event"));
+            _this.trigger(evt, null);
         });
         // Link playback events to the corresponding callbacks
         playback$.subscribe({
@@ -1916,7 +1936,7 @@ var Player = /** @class */ (function (_super) {
             return;
         }
         contentInfos.manifest = manifest;
-        this._priv_lastContentPlaybackInfos.manifest = manifest;
+        this._priv_reloadingMetadata.manifest = manifest;
         var initialAudioTrack = contentInfos.initialAudioTrack, initialTextTrack = contentInfos.initialTextTrack;
         this._priv_trackChoiceManager = new TrackChoiceManager({
             preferTrickModeTracks: this._priv_preferTrickModeTracks,
@@ -2218,14 +2238,10 @@ var Player = /** @class */ (function (_super) {
             log.warn("API: Cannot perform time update: no content loaded.");
             return;
         }
-        if (this.state === "RELOADING" /* PLAYER_STATES.RELOADING */) {
-            return;
-        }
         var _b = this._priv_contentInfos, isDirectFile = _b.isDirectFile, manifest = _b.manifest;
         if ((!isDirectFile && manifest === null) || isNullOrUndefined(observation)) {
             return;
         }
-        this._priv_lastContentPlaybackInfos.lastPlaybackPosition = observation.position;
         var maximumPosition = manifest !== null ? manifest.getMaximumSafePosition() :
             undefined;
         var positionData = {
@@ -2233,9 +2249,11 @@ var Player = /** @class */ (function (_super) {
             duration: observation.duration,
             playbackRate: observation.playbackRate,
             maximumBufferTime: maximumPosition,
-            // TODO fix higher up?
-            bufferGap: isFinite(observation.bufferGap) ? observation.bufferGap :
-                0,
+            // TODO bufferGap may be undefined
+            bufferGap: observation.bufferGap === undefined ||
+                !isFinite(observation.bufferGap) ?
+                0 :
+                observation.bufferGap,
         };
         if (manifest !== null &&
             manifest.isLive &&
@@ -2294,5 +2312,5 @@ var Player = /** @class */ (function (_super) {
     };
     return Player;
 }(EventEmitter));
-Player.version = /* PLAYER_VERSION */ "3.29.0-dev.2022091600";
+Player.version = /* PLAYER_VERSION */ "3.29.0-dev.2022103100";
 export default Player;

package/dist/_esm5.processed/core/api/tracks_management/media_element_track_choice_manager.js

@@ -28,7 +28,11 @@ var __extends = (this && this.__extends) || (function () {
         d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
     };
 })();
-import assert from "../../../utils/assert";
+/**
+ * /!\ This file is feature-switchable.
+ * It always should be imported through the `features` object.
+ */
+import { enableAudioTrack } from "../../../compat";
 import EventEmitter from "../../../utils/event_emitter";
 import normalizeLanguage from "../../../utils/languages";
 /**
@@ -747,15 +751,10 @@ var MediaElementTrackChoiceManager = /** @class */ (function (_super) {
      * @param {number} index}
      */
     MediaElementTrackChoiceManager.prototype._enableAudioTrackFromIndex = function (index) {
-        assert(index < this._audioTracks.length);
-        // Seen on Safari MacOS only (2022-02-14), not disabling ALL audio tracks
-        // first (even the wanted one), can lead to the media not playing.
-        for (var _i = 0, _a = this._audioTracks; _i < _a.length; _i++) {
-            var audioTrack = _a[_i];
-            audioTrack.nativeTrack.enabled = false;
-        }
-        this._audioTracks[index].nativeTrack.enabled = true;
-        return;
+        enableAudioTrack(this._audioTracks.map(function (_a) {
+            var nativeTrack = _a.nativeTrack;
+            return nativeTrack;
+        }), index);
     };
     return MediaElementTrackChoiceManager;
 }(EventEmitter));

package/dist/_esm5.processed/core/decrypt/__tests__/__global__/utils.js

@@ -257,7 +257,7 @@ export function mockCompat(exportedFunctions) {
     var mockGetInitData = jest.fn(function (encryptedEvent) {
         return encryptedEvent;
     });
-    jest.mock("../../../../compat", function () { return (__assign({ events: mockEvents, requestMediaKeySystemAccess: mockRmksa, setMediaKeys: mockSetMediaKeys, getInitData: mockGetInitData, generateKeyRequest: mockGenerateKeyRequest }, exportedFunctions)); });
+    jest.mock("../../../../compat", function () { return (__assign({ events: mockEvents, requestMediaKeySystemAccess: mockRmksa, setMediaKeys: mockSetMediaKeys, getInitData: mockGetInitData, generateKeyRequest: mockGenerateKeyRequest, shouldRenewMediaKeySystemAccess: jest.fn(function () { return false; }), canReuseMediaKeys: jest.fn(function () { return true; }) }, exportedFunctions)); });
     return { mockEvents: mockEvents, eventTriggers: { triggerEncrypted: triggerEncrypted, triggerKeyMessage: triggerKeyMessage, triggerKeyError: triggerKeyError, triggerKeyStatusesChange: triggerKeyStatusesChange },
         mockRequestMediaKeySystemAccess: mockRmksa, mockGetInitData: mockGetInitData, mockSetMediaKeys: mockSetMediaKeys, mockGenerateKeyRequest: mockGenerateKeyRequest };
 }

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

@@ -49,7 +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 { requestMediaKeySystemAccess, shouldRenewMediaKeys, } from "../../compat";
+import { requestMediaKeySystemAccess, shouldRenewMediaKeySystemAccess, } from "../../compat";
 import config from "../../config";
 import { EncryptedMediaError } from "../../errors";
 import log from "../../log";
@@ -64,7 +64,7 @@ import MediaKeysInfosStore from "./utils/media_keys_infos_store";
  */
 function checkCachedMediaKeySystemAccess(keySystems, currentKeySystemAccess, currentKeySystemOptions) {
     var mksConfiguration = currentKeySystemAccess.getConfiguration();
-    if (shouldRenewMediaKeys() || mksConfiguration == null) {
+    if (shouldRenewMediaKeySystemAccess() || mksConfiguration == null) {
         return null;
     }
     var firstCompatibleOption = keySystems.filter(function (ks) {
@@ -157,7 +157,7 @@ function buildKeySystemConfigurations(ksName, keySystem) {
     // More details here:
     // https://storage.googleapis.com/wvdocs/Chrome_EME_Changes_and_Best_Practices.pdf
     // https://www.w3.org/TR/encrypted-media/#get-supported-configuration-and-consent
-    var videoCapabilities = flatMap(audioRobustnesses, function (robustness) {
+    var videoCapabilities = flatMap(videoRobustnesses, function (robustness) {
         return ["video/mp4;codecs=\"avc1.4d401e\"",
             "video/mp4;codecs=\"avc1.42e01e\"",
             "video/webm;codecs=\"vp8\""].map(function (contentType) {

package/dist/_esm5.processed/core/decrypt/get_media_keys.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 { canReuseMediaKeys, } from "../../compat";
 import { EncryptedMediaError } from "../../errors";
 import log from "../../log";
 import isNullOrUndefined from "../../utils/is_null_or_undefined";
@@ -100,7 +101,9 @@ export default function getMediaKeysInfos(mediaElement, keySystemsConfigs, cance
                     _a = evt.value, options = _a.options, mediaKeySystemAccess = _a.mediaKeySystemAccess;
                     currentState = MediaKeysInfosStore.getState(mediaElement);
                     persistentSessionsStore = createPersistentSessionsStorage(options);
-                    if (currentState !== null && evt.type === "reuse-media-key-system-access") {
+                    if (canReuseMediaKeys() &&
+                        currentState !== null &&
+                        evt.type === "reuse-media-key-system-access") {
                         mediaKeys_1 = currentState.mediaKeys, loadedSessionsStore_1 = currentState.loadedSessionsStore;
                         // We might just rely on the currently attached MediaKeys instance.
                         // First check if server certificate parameters are the same than in the

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

@@ -0,0 +1,98 @@
+/**
+ * Copyright 2015 CANAL+ Group
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * 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.
+ *
+ * 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.
+ *
+ * @class CdnPrioritizer
+ */
+export default class CdnPrioritizer extends EventEmitter<ICdnPrioritizerEvents> {
+    /**
+     * Structure keeping a list of CDN currently downgraded.
+     * Downgraded CDN immediately have a lower priority than any non-downgraded
+     * CDN for a specific amount of time.
+     */
+    private _downgradedCdnList;
+    /**
+     * @param {Object} destroySignal
+     */
+    constructor(destroySignal: CancellationSignal);
+    /**
+     * From the list of __ALL__ CDNs available to a resource, return them in the
+     * order in which requests should be performed.
+     *
+     * Note: It is VERY important to include all CDN that are able to reach the
+     * wanted resource, even those which will in the end not be used anyway.
+     * If some CDN are not communicated, the `CdnPrioritizer` might wrongly
+     * consider that the current resource don't have any of the CDN prioritized
+     * internally and return other CDN which should have been forbidden if it knew
+     * about the other, non-used, ones.
+     *
+     * @param {Array.<string>} everyCdnForResource - Array of ALL available CDN
+     * able to reach the wanted resource - even those which might not be used in
+     * the end.
+     * @returns {Array.<Object>} - Array of CDN that can be tried to reach the
+     * resource, sorted by order of CDN preference, according to the
+     * `CdnPrioritizer`'s own list of priorities.
+     */
+    getCdnPreferenceForResource(everyCdnForResource: ICdnMetadata[]): ICdnMetadata[];
+    /**
+     * Limit usage of the CDN for a configured amount of time.
+     * Call this method if you encountered an issue with that CDN which leads you
+     * to want to prevent its usage currently.
+     *
+     * Note that the CDN can still be the preferred one if no other CDN exist for
+     * a wanted resource.
+     * @param {string} metadata
+     */
+    downgradeCdn(metadata: ICdnMetadata): void;
+    /**
+     * From the list of __ALL__ CDNs available to a resource, return them in the
+     * order in which requests should be performed.
+     *
+     * Note: It is VERY important to include all CDN that are able to reach the
+     * wanted resource, even those which will in the end not be used anyway.
+     * If some CDN are not communicated, the `CdnPrioritizer` might wrongly
+     * consider that the current resource don't have any of the CDN prioritized
+     * internally and return other CDN which should have been forbidden if it knew
+     * about the other, non-used, ones.
+     *
+     * @param {Array.<string>} everyCdnForResource - Array of ALL available CDN
+     * able to reach the wanted resource - even those which might not be used in
+     * the end.
+     * @returns {Array.<string>} - Array of CDN that can be tried to reach the
+     * resource, sorted by order of CDN preference, according to the
+     * `CdnPrioritizer`'s own list of priorities.
+     */
+    private _innerGetCdnPreferenceForResource;
+    /**
+     * @param {number} index
+     */
+    private _removeIndexFromDowngradeList;
+}
+export interface ICdnPrioritizerEvents {
+    warnings: IPlayerError[];
+    priorityChange: null;
+}

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

@@ -0,0 +1,173 @@
+/**
+ * Copyright 2015 CANAL+ Group
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+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.
+ *
+ * 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.
+ *
+ * @class CdnPrioritizer
+ */
+var CdnPrioritizer = /** @class */ (function (_super) {
+    __extends(CdnPrioritizer, _super);
+    /**
+     * @param {Object} destroySignal
+     */
+    function CdnPrioritizer(destroySignal) {
+        var _this = _super.call(this) || this;
+        _this._downgradedCdnList = { metadata: [], timeouts: [] };
+        destroySignal.register(function () {
+            for (var _i = 0, _a = _this._downgradedCdnList.timeouts; _i < _a.length; _i++) {
+                var timeout = _a[_i];
+                clearTimeout(timeout);
+            }
+            _this._downgradedCdnList = { metadata: [], timeouts: [] };
+        });
+        return _this;
+    }
+    /**
+     * From the list of __ALL__ CDNs available to a resource, return them in the
+     * order in which requests should be performed.
+     *
+     * Note: It is VERY important to include all CDN that are able to reach the
+     * wanted resource, even those which will in the end not be used anyway.
+     * If some CDN are not communicated, the `CdnPrioritizer` might wrongly
+     * consider that the current resource don't have any of the CDN prioritized
+     * internally and return other CDN which should have been forbidden if it knew
+     * about the other, non-used, ones.
+     *
+     * @param {Array.<string>} everyCdnForResource - Array of ALL available CDN
+     * able to reach the wanted resource - even those which might not be used in
+     * the end.
+     * @returns {Array.<Object>} - Array of CDN that can be tried to reach the
+     * resource, sorted by order of CDN preference, according to the
+     * `CdnPrioritizer`'s own list of priorities.
+     */
+    CdnPrioritizer.prototype.getCdnPreferenceForResource = function (everyCdnForResource) {
+        if (everyCdnForResource.length <= 1) {
+            // The huge majority of contents have only one CDN available.
+            // Here, prioritizing make no sense.
+            return everyCdnForResource;
+        }
+        return this._innerGetCdnPreferenceForResource(everyCdnForResource);
+    };
+    /**
+     * Limit usage of the CDN for a configured amount of time.
+     * Call this method if you encountered an issue with that CDN which leads you
+     * to want to prevent its usage currently.
+     *
+     * Note that the CDN can still be the preferred one if no other CDN exist for
+     * a wanted resource.
+     * @param {string} metadata
+     */
+    CdnPrioritizer.prototype.downgradeCdn = function (metadata) {
+        var _this = this;
+        var indexOf = indexOfMetadata(this._downgradedCdnList.metadata, metadata);
+        if (indexOf >= 0) {
+            this._removeIndexFromDowngradeList(indexOf);
+        }
+        var DEFAULT_CDN_DOWNGRADE_TIME = config.getCurrent().DEFAULT_CDN_DOWNGRADE_TIME;
+        var downgradeTime = DEFAULT_CDN_DOWNGRADE_TIME;
+        this._downgradedCdnList.metadata.push(metadata);
+        var timeout = window.setTimeout(function () {
+            var newIndex = indexOfMetadata(_this._downgradedCdnList.metadata, metadata);
+            if (newIndex >= 0) {
+                _this._removeIndexFromDowngradeList(newIndex);
+            }
+            _this.trigger("priorityChange", null);
+        }, downgradeTime);
+        this._downgradedCdnList.timeouts.push(timeout);
+        this.trigger("priorityChange", null);
+    };
+    /**
+     * From the list of __ALL__ CDNs available to a resource, return them in the
+     * order in which requests should be performed.
+     *
+     * Note: It is VERY important to include all CDN that are able to reach the
+     * wanted resource, even those which will in the end not be used anyway.
+     * If some CDN are not communicated, the `CdnPrioritizer` might wrongly
+     * consider that the current resource don't have any of the CDN prioritized
+     * internally and return other CDN which should have been forbidden if it knew
+     * about the other, non-used, ones.
+     *
+     * @param {Array.<string>} everyCdnForResource - Array of ALL available CDN
+     * able to reach the wanted resource - even those which might not be used in
+     * the end.
+     * @returns {Array.<string>} - Array of CDN that can be tried to reach the
+     * resource, sorted by order of CDN preference, according to the
+     * `CdnPrioritizer`'s own list of priorities.
+     */
+    CdnPrioritizer.prototype._innerGetCdnPreferenceForResource = function (everyCdnForResource) {
+        var _this = this;
+        var _a = everyCdnForResource
+            .reduce(function (acc, elt) {
+            if (_this._downgradedCdnList.metadata.some(function (c) { return c.id === elt.id &&
+                c.baseUrl === elt.baseUrl; })) {
+                acc[1].push(elt);
+            }
+            else {
+                acc[0].push(elt);
+            }
+            return acc;
+        }, [[], []]), allowedInOrder = _a[0], downgradedInOrder = _a[1];
+        return allowedInOrder.concat(downgradedInOrder);
+    };
+    /**
+     * @param {number} index
+     */
+    CdnPrioritizer.prototype._removeIndexFromDowngradeList = function (index) {
+        this._downgradedCdnList.metadata.splice(index, 1);
+        var oldTimeout = this._downgradedCdnList.timeouts.splice(index, 1);
+        clearTimeout(oldTimeout[0]);
+    };
+    return CdnPrioritizer;
+}(EventEmitter));
+export default CdnPrioritizer;
+/**
+ * Find the index of the given CDN metadata in a CDN metadata array.
+ * Returns `-1` if not found.
+ * @param {Array.<Object>} arr
+ * @param {Object} elt
+ * @returns {number}
+ */
+function indexOfMetadata(arr, elt) {
+    if (arr.length === 0) {
+        return -1;
+    }
+    return elt.id !== undefined ? arrayFindIndex(arr, function (m) { return m.id === elt.id; }) :
+        arrayFindIndex(arr, function (m) { return m.baseUrl === elt.baseUrl; });
+}

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

@@ -57,7 +57,7 @@ import assert from "../../../utils/assert";
 import isNullOrUndefined from "../../../utils/is_null_or_undefined";
 import TaskCanceller from "../../../utils/task_canceller";
 import errorSelector from "../utils/error_selector";
-import { tryRequestPromiseWithBackoff, } from "../utils/try_urls_with_backoff";
+import { scheduleRequestPromise, } from "../utils/schedule_request";
 /**
  * Class allowing to facilitate the task of loading and parsing a Manifest.
  * @class ManifestFetcher
@@ -156,7 +156,7 @@ var ManifestFetcher = /** @class */ (function () {
                 var resolveManifestUrl = pipelines.resolveManifestUrl;
                 assert(resolveManifestUrl !== undefined);
                 var callResolver = function () { return resolveManifestUrl(resolverUrl, canceller.signal); };
-                return tryRequestPromiseWithBackoff(callResolver, backoffSettings, canceller.signal);
+                return scheduleRequestPromise(callResolver, backoffSettings, canceller.signal);
             }
             /**
              * Call the loader part of the pipeline, retrying if it fails according
@@ -174,7 +174,7 @@ var ManifestFetcher = /** @class */ (function () {
                     requestTimeout = undefined;
                 }
                 var callLoader = function () { return loadManifest(manifestUrl, { timeout: requestTimeout }, canceller.signal); };
-                return tryRequestPromiseWithBackoff(callLoader, backoffSettings, canceller.signal);
+                return scheduleRequestPromise(callLoader, backoffSettings, canceller.signal);
             }
         });
     };
@@ -258,7 +258,7 @@ var ManifestFetcher = /** @class */ (function () {
                         switch (_a.label) {
                             case 0:
                                 _a.trys.push([0, 2, , 3]);
-                                return [4 /*yield*/, tryRequestPromiseWithBackoff(performRequest, backoffSettings, canceller.signal)];
+                                return [4 /*yield*/, scheduleRequestPromise(performRequest, backoffSettings, canceller.signal)];
                             case 1:
                                 data = _a.sent();
                                 return [2 /*return*/, data];