rx-player 3.26.1 → 3.26.2

package/dist/_esm5.processed/core/eme/eme_manager.js

@@ -13,8 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { concat as observableConcat, EMPTY, merge as observableMerge, of as observableOf, ReplaySubject, throwError, } from "rxjs";
-import { catchError, filter, ignoreElements, map, mergeMap, shareReplay, take, tap, } from "rxjs/operators";
+import { catchError, concat as observableConcat, EMPTY, filter, ignoreElements, map, merge as observableMerge, mergeMap, of as observableOf, ReplaySubject, shareReplay, take, tap, throwError, } from "rxjs";
 import { events, generateKeyRequest, getInitData, } from "../../compat/";
 import config from "../../config";
 import { EncryptedMediaError } from "../../errors";
@@ -80,12 +79,12 @@ export default function EMEManager(mediaElement, keySystemsConfigs, contentProte
         return evt.type === "attached-media-keys";
     }), take(1));
     /** Parsed `encrypted` events coming from the HTMLMediaElement. */
-    var mediaEncryptedEvents$ = onEncrypted$(mediaElement).pipe(tap(function (evt) {
-        log.debug("EME: Encrypted event received from media element.", evt);
+    var mediaEncryptedEvents$ = onEncrypted$(mediaElement).pipe(tap(function () {
+        log.debug("EME: Encrypted event received from media element.");
     }), filterMap(function (evt) { return getInitData(evt); }, null), shareReplay({ refCount: true })); // multiple Observables listen to that one
     // as soon as the EMEManager is subscribed
     /** Encryption events coming from the `contentProtections$` argument. */
-    var externalEvents$ = contentProtections$.pipe(tap(function (evt) { log.debug("EME: Encrypted event received from Player", evt); }));
+    var externalEvents$ = contentProtections$.pipe(tap(function () { log.debug("EME: Encrypted event received from Player"); }));
     /** Emit events signaling that an encryption initialization data is encountered. */
     var initializationData$ = observableMerge(externalEvents$, mediaEncryptedEvents$);
     /** Create MediaKeySessions and handle the corresponding events. */

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

@@ -13,8 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { defer as observableDefer, of as observableOf, throwError as observableThrow, } from "rxjs";
-import { catchError, map, } from "rxjs/operators";
+import { catchError, defer as observableDefer, map, of as observableOf, throwError as observableThrow, } from "rxjs";
 import { requestMediaKeySystemAccess, shouldRenewMediaKeys, } from "../../compat";
 import config from "../../config";
 import { EncryptedMediaError } from "../../errors";
@@ -170,7 +169,7 @@ export default function getMediaKeySystemAccess(mediaElement, keySystemsConfigs)
             // one as exactly the same compatibility options.
             var cachedKeySystemAccess = checkCachedMediaKeySystemAccess(keySystemsConfigs, currentState.mediaKeySystemAccess, currentState.keySystemOptions);
             if (cachedKeySystemAccess !== null) {
-                log.info("EME: Found cached compatible keySystem", cachedKeySystemAccess);
+                log.info("EME: Found cached compatible keySystem");
                 return observableOf({
                     type: "reuse-media-key-system-access",
                     value: { mediaKeySystemAccess: cachedKeySystemAccess.keySystemAccess,
@@ -228,8 +227,8 @@ export default function getMediaKeySystemAccess(mediaElement, keySystemsConfigs)
             }
             var _a = keySystemsType[index], keyName = _a.keyName, keyType = _a.keyType, keySystemOptions = _a.keySystemOptions;
             var keySystemConfigurations = buildKeySystemConfigurations(keyName, keySystemOptions);
-            log.debug("EME: Request keysystem access " + keyType + "," +
-                (index + 1 + " of " + keySystemsType.length), keySystemConfigurations);
+            log.debug("EME: Request keysystem access ".concat(keyType, ",") +
+                "".concat(index + 1, " of ").concat(keySystemsType.length), keySystemConfigurations);
             return requestMediaKeySystemAccess(keyType, keySystemConfigurations).pipe(map(function (keySystemAccess) {
                 log.info("EME: Found compatible keysystem", keyType, keySystemConfigurations);
                 return { type: "create-media-key-system-access",

package/dist/_esm5.processed/core/eme/get_media_keys.js

@@ -13,8 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { of as observableOf, } from "rxjs";
-import { catchError, map, mergeMap, } from "rxjs/operators";
+import { catchError, map, mergeMap, of as observableOf, } from "rxjs";
 import { EncryptedMediaError } from "../../errors";
 import log from "../../log";
 import castToObservable from "../../utils/cast_to_observable";
@@ -63,7 +62,7 @@ export default function getMediaKeysInfos(mediaElement, keySystemsConfigs) {
             }
         }
         return createMediaKeys(mediaKeySystemAccess).pipe(map(function (mediaKeys) {
-            log.info("EME: MediaKeys created with success", mediaKeys);
+            log.info("EME: MediaKeys created with success");
             var loadedSessionsStore = new LoadedSessionsStore(mediaKeys);
             return { mediaKeys: mediaKeys, mediaKeySystemAccess: mediaKeySystemAccess, stores: { loadedSessionsStore: loadedSessionsStore, persistentSessionsStore: persistentSessionsStore }, options: options };
         }));

package/dist/_esm5.processed/core/eme/get_session.js

@@ -13,8 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { concat as observableConcat, defer as observableDefer, of as observableOf, } from "rxjs";
-import { map, mergeMap, } from "rxjs/operators";
+import { concat as observableConcat, defer as observableDefer, map, mergeMap, of as observableOf, } from "rxjs";
 import log from "../../log";
 import cleanOldLoadedSessions from "./clean_old_loaded_sessions";
 import createSession from "./create_session";

package/dist/_esm5.processed/core/eme/init_media_keys.js

@@ -13,10 +13,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { of as observableOf, ReplaySubject, } from "rxjs";
-import { mapTo, mergeMap, startWith, take, } from "rxjs/operators";
+import { filter, mapTo, mergeMap, of as observableOf, startWith, take, } from "rxjs";
 import log from "../../log";
 import isNullOrUndefined from "../../utils/is_null_or_undefined";
+import createSharedReference from "../../utils/reference";
 import attachMediaKeys, { disableMediaKeys, } from "./attach_media_keys";
 import getDrmSystemId from "./get_drm_system_id";
 import getMediaKeysInfos from "./get_media_keys";
@@ -44,7 +44,7 @@ export default function initMediaKeys(mediaElement, keySystemsConfigs) {
             options.licenseStorage.disableRetroCompatibility === true) {
             initializationDataSystemId = getDrmSystemId(mediaKeySystemAccess.keySystem);
         }
-        var attachMediaKeys$ = new ReplaySubject(1);
+        var canAttachMediaKeys = createSharedReference(false);
         var shouldDisableOldMediaKeys = mediaElement.mediaKeys !== null &&
             mediaElement.mediaKeys !== undefined &&
             mediaKeys !== mediaElement.mediaKeys;
@@ -55,12 +55,12 @@ export default function initMediaKeys(mediaElement, keySystemsConfigs) {
         }
         return disableOldMediaKeys$.pipe(mergeMap(function () {
             log.debug("EME: Attaching current MediaKeys");
-            return attachMediaKeys$.pipe(mergeMap(function () {
+            return canAttachMediaKeys.asObservable().pipe(filter(function (canAttach) { return canAttach; }), mergeMap(function () {
                 var stateToAttatch = { loadedSessionsStore: stores.loadedSessionsStore, mediaKeySystemAccess: mediaKeySystemAccess, mediaKeys: mediaKeys, keySystemOptions: options };
                 return attachMediaKeys(mediaElement, stateToAttatch);
             }), take(1), mapTo({ type: "attached-media-keys",
                 value: { mediaKeySystemAccess: mediaKeySystemAccess, mediaKeys: mediaKeys, stores: stores, options: options } }), startWith({ type: "created-media-keys",
-                value: { mediaKeySystemAccess: mediaKeySystemAccess, initializationDataSystemId: initializationDataSystemId, mediaKeys: mediaKeys, stores: stores, options: options, attachMediaKeys$: attachMediaKeys$ } }));
+                value: { mediaKeySystemAccess: mediaKeySystemAccess, initializationDataSystemId: initializationDataSystemId, mediaKeys: mediaKeys, stores: stores, options: options, canAttachMediaKeys: canAttachMediaKeys } }));
         }));
     }));
 }

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

@@ -28,8 +28,7 @@ var __extends = (this && this.__extends) || (function () {
         d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
     };
 })();
-import { concat as observableConcat, defer as observableDefer, EMPTY, identity, merge as observableMerge, of as observableOf, Subject, TimeoutError, } from "rxjs";
-import { catchError, concatMap, map, mapTo, mergeMap, startWith, takeUntil, tap, timeout, } from "rxjs/operators";
+import { catchError, concat as observableConcat, concatMap, defer as observableDefer, EMPTY, identity, map, merge as observableMerge, mergeMap, of as observableOf, startWith, Subject, takeUntil, tap, timeout, TimeoutError, } from "rxjs";
 import { events, } from "../../compat";
 import { EncryptedMediaError, } from "../../errors";
 import log from "../../log";
@@ -70,7 +69,7 @@ export { BlacklistedSessionError };
  * @returns {Observable}
  */
 export default function SessionEventsListener(session, keySystemOptions, keySystem, initializationData) {
-    log.info("EME: Binding session events", session);
+    log.info("EME: Binding session events", session.sessionId);
     var sessionWarningSubject$ = new Subject();
     var _a = keySystemOptions.getLicenseConfig, getLicenseConfig = _a === void 0 ? {} : _a;
     var keyErrors = onKeyError$(session)
@@ -84,7 +83,7 @@ export default function SessionEventsListener(session, keySystemOptions, keySyst
         var messageType = isNonEmptyString(messageEvent.messageType) ?
             messageEvent.messageType :
             "license-request";
-        log.info("EME: Received message event, type " + messageType, session, messageEvent);
+        log.info("EME: Received message event, type ".concat(messageType), session.sessionId, messageEvent);
         var getLicense$ = observableDefer(function () {
             var getLicense = keySystemOptions.getLicense(message, messageType);
             var getLicenseTimeout = isNullOrUndefined(getLicenseConfig.timeout) ?
@@ -192,8 +191,8 @@ function updateSessionWithMessage(session, message, initializationData) {
         var reason = error instanceof Error ? error.toString() :
             "`session.update` failed";
         throw new EncryptedMediaError("KEY_UPDATE_ERROR", reason);
-    }), tap(function () { log.info("EME: MediaKeySession update succeeded."); }), mapTo({ type: "session-updated",
-        value: { session: session, license: message, initializationData: initializationData } }));
+    }), tap(function () { log.info("EME: MediaKeySession update succeeded."); }), map(function () { return ({ type: "session-updated",
+        value: { session: session, license: message, initializationData: initializationData } }); }));
 }
 /**
  * @param {MediaKeySession}
@@ -202,7 +201,7 @@ function updateSessionWithMessage(session, message, initializationData) {
  * @returns {Observable}
  */
 function handleKeyStatusesChangeEvent(session, keySystemOptions, keySystem, keyStatusesEvent) {
-    log.info("EME: keystatuseschange event received", session, keyStatusesEvent);
+    log.info("EME: keystatuseschange event received", session.sessionId);
     var callback$ = observableDefer(function () {
         return tryCatch(function () {
             if (typeof keySystemOptions.onKeyStatusesChange !== "function") {

package/dist/_esm5.processed/core/eme/set_server_certificate.js

@@ -13,8 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { defer as observableDefer, EMPTY, of as observableOf, } from "rxjs";
-import { catchError, ignoreElements, tap, } from "rxjs/operators";
+import { catchError, defer as observableDefer, EMPTY, ignoreElements, tap, of as observableOf, } from "rxjs";
 import { EncryptedMediaError } from "../../errors";
 import log from "../../log";
 import castToObservable from "../../utils/cast_to_observable";
@@ -70,7 +69,13 @@ export default function trySettingServerCertificate(mediaKeys, serverCertificate
         // know if we attached the server certificate or not.
         // Calling `prepare` allow to invalidate temporarily that status.
         ServerCertificateStore.prepare(mediaKeys);
-        return setServerCertificate(mediaKeys, serverCertificate).pipe(tap(function () { ServerCertificateStore.set(mediaKeys, serverCertificate); }), ignoreElements(), catchError(function (error) { return observableOf({
+        return setServerCertificate(mediaKeys, serverCertificate).pipe(tap(function () { ServerCertificateStore.set(mediaKeys, serverCertificate); }), 
+        // NOTE As of now (RxJS 7.4.0), RxJS defines `ignoreElements` default
+        // first type parameter as `any` instead of the perfectly fine `unknown`,
+        // leading to linter issues, as it forbids the usage of `any`.
+        // This is why we're disabling the eslint rule.
+        /* eslint-disable @typescript-eslint/no-unsafe-argument */
+        ignoreElements(), catchError(function (error) { return observableOf({
             type: "warning",
             // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
             value: error,

package/dist/_esm5.processed/core/eme/types.d.ts

@@ -13,9 +13,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { Subject } from "rxjs";
 import { ICustomMediaKeys, ICustomMediaKeySession, ICustomMediaKeySystemAccess } from "../../compat";
 import { ICustomError } from "../../errors";
+import { ISharedReference } from "../../utils/reference";
 import LoadedSessionsStore from "./utils/loaded_sessions_store";
 import PersistentSessionsStore from "./utils/persistent_sessions_store";
 /** Information about the encryption initialization data. */
@@ -73,8 +73,10 @@ export interface IEncryptedEvent {
  * current content.
  * This is necessary before creating a MediaKeySession which will allow
  * encryption keys to be communicated.
- * It carries a subject (attachMediaKeys$) that will be used by the init to
- * ask the EME to attach the mediakeys.
+ *
+ * It carries a shared reference (`canAttachMediaKeys`) that should be setted to
+ * `true` to indicate that RxPlayer's EME logic can start to attach the
+ * `MediaKeys` instance to the HTMLMediaElement.
  */
 export interface ICreatedMediaKeysEvent {
     type: "created-media-keys";
@@ -106,9 +108,15 @@ export interface ICreatedMediaKeysEvent {
         initializationDataSystemId: string | undefined;
         /** The MediaKeys instance. */
         mediaKeys: MediaKeys | ICustomMediaKeys;
+        /** Stores allowing to cache MediaKeySession instances. */
         stores: IMediaKeySessionStores;
+        /** key system options considered. */
         options: IKeySystemOption;
-        attachMediaKeys$: Subject<void>;
+        /**
+         * Shared reference that should be set to `true` once the `MediaKeys`
+         * instance can be attached to the HTMLMediaElement.
+         */
+        canAttachMediaKeys: ISharedReference<boolean>;
     };
 }
 /**

package/dist/_esm5.processed/core/eme/utils/close_session.js

@@ -13,8 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { of as observableOf, timer, race as observableRace, } from "rxjs";
-import { catchError, mergeMap, take, tap, } from "rxjs/operators";
+import { catchError, mergeMap, of as observableOf, take, tap, timer, race as observableRace, } from "rxjs";
 import { closeSession, } from "../../../compat";
 import { onKeyMessage$, onKeyStatusesChange$ } from "../../../compat/event_listeners";
 import config from "../../../config";
@@ -39,7 +38,7 @@ export default function safelyCloseMediaKeySession(mediaKeySession) {
      * @returns {Observable}
      */
     function recursivelyTryToCloseMediaKeySession(retryNb) {
-        log.debug("EME: Trying to close a MediaKeySession", mediaKeySession, retryNb);
+        log.debug("EME: Trying to close a MediaKeySession", mediaKeySession.sessionId, retryNb);
         return closeSession(mediaKeySession).pipe(tap(function () { log.debug("EME: Succeeded to close MediaKeySession"); }), catchError(function (err) {
             // Unitialized MediaKeySession may not close properly until their
             // corresponding `generateRequest` or `load` call are handled by the

package/dist/_esm5.processed/core/eme/utils/is_session_usable.js

@@ -33,7 +33,7 @@ export default function isSessionUsable(loadedSession) {
         keyStatuses.push(keyStatus);
     });
     if (keyStatuses.length <= 0) {
-        log.debug("EME: isSessionUsable: MediaKeySession given has an empty keyStatuses", loadedSession);
+        log.debug("EME: isSessionUsable: MediaKeySession given has an empty keyStatuses", loadedSession.sessionId);
         return false;
     }
     if (arrayIncludes(keyStatuses, "expired")) {

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

@@ -13,8 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { concat as observableConcat, defer as observableDefer, EMPTY, merge as observableMerge, of as observableOf, } from "rxjs";
-import { ignoreElements } from "rxjs/operators";
+import { concat as observableConcat, defer as observableDefer, EMPTY, ignoreElements, merge as observableMerge, of as observableOf, } from "rxjs";
 import { EncryptedMediaError } from "../../../errors";
 import log from "../../../log";
 import isNullOrUndefined from "../../../utils/is_null_or_undefined";
@@ -110,10 +109,10 @@ var LoadedSessionsStore = /** @class */ (function () {
             })
                 .catch(function (e) {
                 // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
-                log.warn("EME-LSS: MediaKeySession.closed rejected: " + e);
+                log.warn("EME-LSS: MediaKeySession.closed rejected: ".concat(e));
             });
         }
-        log.debug("EME-LSS: Add MediaKeySession", entry);
+        log.debug("EME-LSS: Add MediaKeySession", entry.sessionType);
         this._storage.store(initializationData, entry);
         return mediaKeySession;
     };

package/dist/_esm5.processed/core/eme/utils/persistent_sessions_store.js

@@ -154,7 +154,7 @@ var PersistentSessionsStore = /** @class */ (function () {
         else if (currentEntry !== null) { // currentEntry has a different sessionId
             this.delete(initData);
         }
-        log.info("EME-PSS: Add new session", sessionId, session);
+        log.info("EME-PSS: Add new session", sessionId);
         this._entries.push({ version: 3, sessionId: sessionId, values: this._formatValuesForStore(initData.values),
             initDataType: initData.type });
         this._save();
@@ -172,12 +172,12 @@ var PersistentSessionsStore = /** @class */ (function () {
             return;
         }
         var entry = this._entries[index];
-        log.warn("EME-PSS: Delete session from store", entry);
+        log.warn("EME-PSS: Delete session from store", entry.sessionId);
         this._entries.splice(index, 1);
         this._save();
     };
     PersistentSessionsStore.prototype.deleteOldSessions = function (sessionsToDelete) {
-        log.info("EME-PSS: Deleting last " + sessionsToDelete + " sessions.");
+        log.info("EME-PSS: Deleting last ".concat(sessionsToDelete, " sessions."));
         if (sessionsToDelete <= 0) {
             return;
         }

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

@@ -14,5 +14,5 @@
  * limitations under the License.
  */
 import ManifestFetcher, { IManifestFetcherParsedResult, IManifestFetcherParserOptions, IManifestFetcherWarningEvent } from "./manifest";
-import SegmentFetcherCreator, { IPrioritizedSegmentFetcher, IPrioritizedSegmentFetcherEvent, ISegmentFetcherChunkCompleteEvent, ISegmentFetcherChunkEvent, ISegmentFetcherCreatorBackoffOptions, ISegmentFetcherEvent, ISegmentFetcherWarning } from "./segment";
-export { ManifestFetcher, SegmentFetcherCreator, IManifestFetcherParserOptions, IManifestFetcherParsedResult, IManifestFetcherWarningEvent, IPrioritizedSegmentFetcher, IPrioritizedSegmentFetcherEvent, ISegmentFetcherEvent, ISegmentFetcherCreatorBackoffOptions, ISegmentFetcherChunkEvent, ISegmentFetcherChunkCompleteEvent, ISegmentFetcherWarning, };
+import SegmentFetcherCreator, { IPrioritizedSegmentFetcher, IPrioritizedSegmentFetcherEvent, ISegmentFetcherChunkCompleteEvent, ISegmentFetcherChunkEvent, ISegmentFetcherCreatorBackoffOptions, ISegmentFetcherEvent, ISegmentFetcherRetry } from "./segment";
+export { ManifestFetcher, SegmentFetcherCreator, IManifestFetcherParserOptions, IManifestFetcherParsedResult, IManifestFetcherWarningEvent, IPrioritizedSegmentFetcher, IPrioritizedSegmentFetcherEvent, ISegmentFetcherEvent, ISegmentFetcherCreatorBackoffOptions, ISegmentFetcherChunkEvent, ISegmentFetcherChunkCompleteEvent, ISegmentFetcherRetry, };

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

@@ -186,7 +186,7 @@ var ManifestFetcher = /** @class */ (function () {
     ManifestFetcher.prototype.parse = function (manifest, parserOptions) {
         return this._parseLoadedManifest({ responseData: manifest,
             size: undefined,
-            duration: undefined }, parserOptions);
+            requestDuration: undefined }, parserOptions);
     };
     /**
      * Parse a Manifest.
@@ -285,7 +285,7 @@ var ManifestFetcher = /** @class */ (function () {
             function emitManifestAndComplete(manifest) {
                 onWarnings(manifest.contentWarnings);
                 var parsingTime = performance.now() - parsingTimeStart;
-                log.info("MF: Manifest parsed in " + parsingTime + "ms");
+                log.info("MF: Manifest parsed in ".concat(parsingTime, "ms"));
                 obs.next({ type: "parsed", manifest: manifest, sendingTime: sendingTime, receivedTime: receivedTime, parsingTime: parsingTime });
                 obs.complete();
             }

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

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 import { IPrioritizedSegmentFetcher, IPrioritizedSegmentFetcherEvent } from "./prioritized_segment_fetcher";
-import { ISegmentFetcherChunkCompleteEvent, ISegmentFetcherChunkEvent, ISegmentFetcherEvent, ISegmentFetcherWarning } from "./segment_fetcher";
+import { ISegmentFetcherChunkCompleteEvent, ISegmentFetcherChunkEvent, ISegmentFetcherEvent, ISegmentFetcherRetry } from "./segment_fetcher";
 import SegmentFetcherCreator, { ISegmentFetcherCreatorBackoffOptions } from "./segment_fetcher_creator";
 export default SegmentFetcherCreator;
-export { IPrioritizedSegmentFetcher, IPrioritizedSegmentFetcherEvent, ISegmentFetcherChunkCompleteEvent, ISegmentFetcherChunkEvent, ISegmentFetcherEvent, ISegmentFetcherWarning, ISegmentFetcherCreatorBackoffOptions, };
+export { IPrioritizedSegmentFetcher, IPrioritizedSegmentFetcherEvent, ISegmentFetcherChunkCompleteEvent, ISegmentFetcherChunkEvent, ISegmentFetcherEvent, ISegmentFetcherRetry, ISegmentFetcherCreatorBackoffOptions, };

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

@@ -14,37 +14,11 @@
  * limitations under the License.
  */
 import { Observable } from "rxjs";
-import ObservablePrioritizer from "./prioritizer";
-import { ISegmentFetcher, ISegmentFetcherEvent, ISegmentLoaderContent } from "./segment_fetcher";
-/**
- * Event sent when a segment request has been temporarly interrupted due to
- * another request with a high priority.
- * The request for that segment will restart (from scratch) when requests with
- * more priority are finished.
- */
-export interface ISegmentFetcherInterruptedEvent {
-    type: "interrupted";
-}
-/**
- * Event sent when a segment request just ended.
- * You can use this event to schedule another task you wanted to perform at best
- * immediately after that one (its priority will be checked).
- */
-export interface IEndedTaskEvent {
-    type: "ended";
-}
-/** Event sent by a `IPrioritizedSegmentFetcher`. */
-export declare type IPrioritizedSegmentFetcherEvent<TSegmentDataType> = ISegmentFetcherEvent<TSegmentDataType> | ISegmentFetcherInterruptedEvent | IEndedTaskEvent;
-/** Oject returned by `applyPrioritizerToSegmentFetcher`. */
-export interface IPrioritizedSegmentFetcher<TSegmentDataType> {
-    /** Create a new request for a segment with a given priority. */
-    createRequest: (content: ISegmentLoaderContent, priority?: number) => Observable<IPrioritizedSegmentFetcherEvent<TSegmentDataType>>;
-    /** Update priority of a request created through `createRequest`. */
-    updatePriority: (observable: Observable<IPrioritizedSegmentFetcherEvent<TSegmentDataType>>, priority: number) => void;
-}
+import ObservablePrioritizer, { IEndedTaskEvent, IInterruptedTaskEvent } from "./prioritizer";
+import { ISegmentFetcher, ISegmentFetcherChunkCompleteEvent, ISegmentFetcherChunkEvent, ISegmentFetcherRetry, ISegmentLoaderContent } from "./segment_fetcher";
 /**
  * This function basically put in relation:
- *   - a SegmentFetcher, which will be used to perform the segment request
+ *   - an `ISegmentFetcher`, which will be used to perform the segment requests
  *   - a prioritizer, which will handle the priority of a segment request
  *
  * and returns functions to fetch segments with a given priority.
@@ -53,3 +27,12 @@ export interface IPrioritizedSegmentFetcher<TSegmentDataType> {
  * @returns {Object}
  */
 export default function applyPrioritizerToSegmentFetcher<TSegmentDataType>(prioritizer: ObservablePrioritizer<IPrioritizedSegmentFetcherEvent<TSegmentDataType>>, fetcher: ISegmentFetcher<TSegmentDataType>): IPrioritizedSegmentFetcher<TSegmentDataType>;
+/** Oject returned by `applyPrioritizerToSegmentFetcher`. */
+export interface IPrioritizedSegmentFetcher<TSegmentDataType> {
+    /** Create a new request for a segment with a given priority. */
+    createRequest: (content: ISegmentLoaderContent, priority?: number) => Observable<IPrioritizedSegmentFetcherEvent<TSegmentDataType>>;
+    /** Update priority of a request created through `createRequest`. */
+    updatePriority: (observable: Observable<IPrioritizedSegmentFetcherEvent<TSegmentDataType>>, priority: number) => void;
+}
+/** Event sent by a `IPrioritizedSegmentFetcher`. */
+export declare type IPrioritizedSegmentFetcherEvent<TSegmentDataType> = ISegmentFetcherChunkEvent<TSegmentDataType> | ISegmentFetcherChunkCompleteEvent | ISegmentFetcherRetry | IInterruptedTaskEvent | IEndedTaskEvent;

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

@@ -13,11 +13,11 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { map } from "rxjs/operators";
+import { map, } from "rxjs";
 import log from "../../../log";
 /**
  * This function basically put in relation:
- *   - a SegmentFetcher, which will be used to perform the segment request
+ *   - an `ISegmentFetcher`, which will be used to perform the segment requests
  *   - a prioritizer, which will handle the priority of a segment request
  *
  * and returns functions to fetch segments with a given priority.
@@ -26,11 +26,7 @@ import log from "../../../log";
  * @returns {Object}
  */
 export default function applyPrioritizerToSegmentFetcher(prioritizer, fetcher) {
-    /**
-     * The Observables returned by `createRequest` are not exactly the same than
-     * the one created by the `ObservablePrioritizer`. Because we still have to
-     * keep a handle on that value.
-     */
+    /** Map returned task to the task as returned by the `ObservablePrioritizer`. */
     var taskHandlers = new WeakMap();
     return {
         /**

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

@@ -14,59 +14,6 @@
  * limitations under the License.
  */
 import { Observable } from "rxjs";
-/**
- * Event sent when the corresponding task is a low-priority task that has just
- * been temporarly interrupted due to another task with a high priority.
- * The task will restart (from scratch) when tasks with more priority are
- * finished.
- */
-export interface IInterruptedTaskEvent {
-    type: "interrupted";
-}
-/** Event sent when the corresponding task emit an event. */
-export interface ITaskDataEvent<T> {
-    type: "data";
-    value: T;
-}
-/**
- * Event sent when the corresponding task has ended (it will then complete).
- * You can use this event to schedule another task you wanted to perform after
- * that one.
- */
-export interface IEndedTaskEvent {
-    type: "ended";
-}
-/** Events sent when a task has been created through the `create` method. */
-export declare type ITaskEvent<T> = IInterruptedTaskEvent | ITaskDataEvent<T> | IEndedTaskEvent;
-/** Options to give to the ObservablePrioritizer. */
-export interface IPrioritizerOptions {
-    /** @see IPrioritizerPrioritySteps */
-    prioritySteps: IPrioritizerPrioritySteps;
-}
-/**
- * Define both the `low` and `high` priority steps:
- *
- *   - Any Observable with a priority number that is lower or equal to the
- *     `high` value will be an Observable with high priority.
- *
- *     When Observables with high priorities are scheduled, they immediately
- *     abort pending Observables with low priorities (which will have then to
- *     wait until all higher-priority Observable have ended before re-starting).
- *
- *   - Any Observable with a priority number that is higher or equal to the
- *     `low` value will be an Observable with low priority.
- *
- *     Pending Observables with low priorities have the added particularity*
- *     of being aborted as soon as a high priority Observable is scheduled.
- *
- *     * Other pending Observables are not aborted when a higher-priority
- *     Observable is scheduled, as their priorities only affect them before
- *     they are started (to know when to start them).
- */
-export interface IPrioritizerPrioritySteps {
-    low: number;
-    high: number;
-}
 /**
  * Create Observables which can be priorized between one another.
  *
@@ -230,3 +177,56 @@ export default class ObservablePrioritizer<T> {
      */
     private _isRunningHighPriorityTasks;
 }
+/**
+ * Event sent when the corresponding task is a low-priority task that has just
+ * been temporarly interrupted due to another task with a high priority.
+ * The task will restart (from scratch) when tasks with more priority are
+ * finished.
+ */
+export interface IInterruptedTaskEvent {
+    type: "interrupted";
+}
+/** Event sent when the corresponding task emit an event. */
+export interface ITaskDataEvent<T> {
+    type: "data";
+    value: T;
+}
+/**
+ * Event sent when the corresponding task has ended (it will then complete).
+ * You can use this event to schedule another task you wanted to perform after
+ * that one.
+ */
+export interface IEndedTaskEvent {
+    type: "ended";
+}
+/** Events sent when a task has been created through the `create` method. */
+export declare type ITaskEvent<T> = IInterruptedTaskEvent | ITaskDataEvent<T> | IEndedTaskEvent;
+/** Options to give to the ObservablePrioritizer. */
+export interface IPrioritizerOptions {
+    /** @see IPrioritizerPrioritySteps */
+    prioritySteps: IPrioritizerPrioritySteps;
+}
+/**
+ * Define both the `low` and `high` priority steps:
+ *
+ *   - Any Observable with a priority number that is lower or equal to the
+ *     `high` value will be an Observable with high priority.
+ *
+ *     When Observables with high priorities are scheduled, they immediately
+ *     abort pending Observables with low priorities (which will have then to
+ *     wait until all higher-priority Observable have ended before re-starting).
+ *
+ *   - Any Observable with a priority number that is higher or equal to the
+ *     `low` value will be an Observable with low priority.
+ *
+ *     Pending Observables with low priorities have the added particularity*
+ *     of being aborted as soon as a high priority Observable is scheduled.
+ *
+ *     * Other pending Observables are not aborted when a higher-priority
+ *     Observable is scheduled, as their priorities only affect them before
+ *     they are started (to know when to start them).
+ */
+export interface IPrioritizerPrioritySteps {
+    low: number;
+    high: number;
+}