rx-player 3.25.2 → 3.26.3-dev.2022021400

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

@@ -13,15 +13,52 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { merge as observableMerge, of as observableOf, Subject, } from "rxjs";
-import { catchError, finalize, map, mergeMap, } from "rxjs/operators";
+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) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+import { Observable, } from "rxjs";
+import config from "../../../config";
 import { formatError, } from "../../../errors";
 import log from "../../../log";
-import tryCatch$ from "../../../utils/rx-try_catch";
-import createRequestScheduler from "../utils/create_request_scheduler";
+import assert from "../../../utils/assert";
+import PPromise from "../../../utils/promise";
+import TaskCanceller from "../../../utils/task_canceller";
 import errorSelector from "../utils/error_selector";
-import { tryRequestObservableWithBackoff, } from "../utils/try_urls_with_backoff";
-import getManifestBackoffOptions from "./get_manifest_backoff_options";
+import { tryRequestPromiseWithBackoff, } from "../utils/try_urls_with_backoff";
+var DEFAULT_MAX_MANIFEST_REQUEST_RETRY = config.DEFAULT_MAX_MANIFEST_REQUEST_RETRY, DEFAULT_MAX_REQUESTS_RETRY_ON_OFFLINE = config.DEFAULT_MAX_REQUESTS_RETRY_ON_OFFLINE, INITIAL_BACKOFF_DELAY_BASE = config.INITIAL_BACKOFF_DELAY_BASE, MAX_BACKOFF_DELAY_BASE = config.MAX_BACKOFF_DELAY_BASE;
 /**
  * Class allowing to facilitate the task of loading and parsing a Manifest.
  * @class ManifestFetcher
@@ -42,48 +79,98 @@ import getManifestBackoffOptions from "./get_manifest_backoff_options";
  */
 var ManifestFetcher = /** @class */ (function () {
     /**
-     * @param {string | undefined} url
-     * @param {Object} pipelines
-     * @param {Object} backoffOptions
+     * Construct a new ManifestFetcher.
+     * @param {string | undefined} url - Default Manifest url, will be used when
+     * no URL is provided to the `fetch` function.
+     * `undefined` if unknown or if a Manifest should be retrieved through other
+     * means than an HTTP request.
+     * @param {Object} pipelines - Transport pipelines used to perform the
+     * Manifest loading and parsing operations.
+     * @param {Object} settings - Configure the `ManifestFetcher`.
      */
-    function ManifestFetcher(url, pipelines, backoffOptions) {
+    function ManifestFetcher(url, pipelines, settings) {
         this._manifestUrl = url;
         this._pipelines = pipelines.manifest;
-        this._backoffOptions = getManifestBackoffOptions(backoffOptions);
+        this._settings = settings;
     }
     /**
-     * (re-)Load the Manifest without yet parsing it.
+     * (re-)Load the Manifest.
+     * This method does not yet parse it, parsing will then be available through
+     * a callback available on the response.
      *
      * You can set an `url` on which that Manifest will be requested.
-     * If not set, the regular Manifest url - defined on the
-     * `ManifestFetcher` instanciation - will be used instead.
+     * If not set, the regular Manifest url - defined on the `ManifestFetcher`
+     * instanciation - will be used instead.
+     *
      * @param {string} [url]
      * @returns {Observable}
      */
     ManifestFetcher.prototype.fetch = function (url) {
         var _this = this;
-        var _a;
-        var requestUrl = url !== null && url !== void 0 ? url : this._manifestUrl;
-        // TODO Remove the resolver completely in the next major version
-        var resolver = (_a = this._pipelines.resolver) !== null && _a !== void 0 ? _a : observableOf;
-        var loader = this._pipelines.loader;
-        return tryCatch$(resolver, { url: requestUrl }).pipe(catchError(function (error) {
-            throw errorSelector(error);
-        }), mergeMap(function (loaderArgument) {
-            var loader$ = tryCatch$(loader, loaderArgument);
-            return tryRequestObservableWithBackoff(loader$, _this._backoffOptions).pipe(catchError(function (error) {
-                throw errorSelector(error);
-            }), map(function (evt) {
-                return evt.type === "retry" ?
-                    ({ type: "warning", value: errorSelector(evt.value) }) :
-                    ({
-                        type: "response",
-                        parse: function (parserOptions) {
-                            return _this._parseLoadedManifest(evt.value.value, parserOptions);
-                        },
-                    });
-            }));
-        }));
+        return new Observable(function (obs) {
+            var pipelines = _this._pipelines;
+            var requestUrl = url !== null && url !== void 0 ? url : _this._manifestUrl;
+            /** `true` if the loading pipeline is already completely executed. */
+            var hasFinishedLoading = false;
+            /** Allows to cancel the loading operation. */
+            var canceller = new TaskCanceller();
+            var backoffSettings = _this._getBackoffSetting(function (err) {
+                obs.next({ type: "warning", value: errorSelector(err) });
+            });
+            var loadingPromise = pipelines.resolveManifestUrl === undefined ?
+                callLoaderWithRetries(requestUrl) :
+                callResolverWithRetries(requestUrl).then(callLoaderWithRetries);
+            loadingPromise
+                .then(function (response) {
+                hasFinishedLoading = true;
+                obs.next({
+                    type: "response",
+                    parse: function (parserOptions) {
+                        return _this._parseLoadedManifest(response, parserOptions);
+                    },
+                });
+                obs.complete();
+            })
+                .catch(function (err) {
+                if (canceller.isUsed) {
+                    // Cancellation has already been handled by RxJS
+                    return;
+                }
+                hasFinishedLoading = true;
+                obs.error(errorSelector(err));
+            });
+            return function () {
+                if (!hasFinishedLoading) {
+                    canceller.cancel();
+                }
+            };
+            /**
+             * Call the resolver part of the pipeline, retrying if it fails according
+             * to the current settings.
+             * Returns the Promise of the last attempt.
+             * /!\ This pipeline should have a `resolveManifestUrl` function defined.
+             * @param {string | undefined}  resolverUrl
+             * @returns {Promise}
+             */
+            function callResolverWithRetries(resolverUrl) {
+                var resolveManifestUrl = pipelines.resolveManifestUrl;
+                assert(resolveManifestUrl !== undefined);
+                var callResolver = function () { return resolveManifestUrl(resolverUrl, canceller.signal); };
+                return tryRequestPromiseWithBackoff(callResolver, backoffSettings, canceller.signal);
+            }
+            /**
+             * Call the loader part of the pipeline, retrying if it fails according
+             * to the current settings.
+             * Returns the Promise of the last attempt.
+             * @param {string | undefined}  resolverUrl
+             * @returns {Promise}
+             */
+            function callLoaderWithRetries(manifestUrl) {
+                var loadManifest = pipelines.loadManifest;
+                var callLoader = function () { return loadManifest(manifestUrl, canceller.signal); };
+                return tryRequestPromiseWithBackoff(callLoader, backoffSettings, canceller.signal);
+            }
+        });
     };
     /**
      * Parse an already loaded Manifest.
@@ -99,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.
@@ -110,40 +197,146 @@ var ManifestFetcher = /** @class */ (function () {
      * @returns {Observable}
      */
     ManifestFetcher.prototype._parseLoadedManifest = function (loaded, parserOptions) {
-        var sendingTime = loaded.sendingTime, receivedTime = loaded.receivedTime;
-        var parsingTimeStart = performance.now();
-        var schedulerWarnings$ = new Subject();
-        var scheduleRequest = createRequestScheduler(this._backoffOptions, schedulerWarnings$);
-        return observableMerge(schedulerWarnings$
-            .pipe(map(function (err) { return ({ type: "warning", value: err }); })), this._pipelines.parser({ response: loaded,
-            url: this._manifestUrl,
-            externalClockOffset: parserOptions.externalClockOffset,
-            previousManifest: parserOptions.previousManifest,
-            scheduleRequest: scheduleRequest,
-            unsafeMode: parserOptions.unsafeMode, }).pipe(catchError(function (error) {
-            throw formatError(error, {
-                defaultCode: "PIPELINE_PARSE_ERROR",
-                defaultReason: "Unknown error when parsing the Manifest",
+        var _this = this;
+        return new Observable(function (obs) {
+            var parsingTimeStart = performance.now();
+            var canceller = new TaskCanceller();
+            var sendingTime = loaded.sendingTime, receivedTime = loaded.receivedTime;
+            var backoffSettings = _this._getBackoffSetting(function (err) {
+                obs.next({ type: "warning", value: errorSelector(err) });
             });
-        }), map(function (parsingEvt) {
-            if (parsingEvt.type === "warning") {
-                var formatted = formatError(parsingEvt.value, {
+            var opts = { externalClockOffset: parserOptions.externalClockOffset,
+                unsafeMode: parserOptions.unsafeMode,
+                previousManifest: parserOptions.previousManifest,
+                originalUrl: _this._manifestUrl };
+            try {
+                var res = _this._pipelines.parseManifest(loaded, opts, onWarnings, canceller.signal, scheduleRequest);
+                if (!isPromise(res)) {
+                    emitManifestAndComplete(res.manifest);
+                }
+                else {
+                    res
+                        .then(function (_a) {
+                        var manifest = _a.manifest;
+                        return emitManifestAndComplete(manifest);
+                    })
+                        .catch(function (err) {
+                        if (canceller.isUsed) {
+                            // Cancellation is already handled by RxJS
+                            return;
+                        }
+                        emitError(err, true);
+                    });
+                }
+            }
+            catch (err) {
+                if (canceller.isUsed) {
+                    // Cancellation is already handled by RxJS
+                    return undefined;
+                }
+                emitError(err, true);
+            }
+            return function () {
+                canceller.cancel();
+            };
+            /**
+             * Perform a request with the same retry mechanisms and error handling
+             * than for a Manifest loader.
+             * @param {Function} performRequest
+             * @returns {Function}
+             */
+            function scheduleRequest(performRequest) {
+                return __awaiter(this, void 0, void 0, function () {
+                    var data, err_1;
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0:
+                                _a.trys.push([0, 2, , 3]);
+                                return [4 /*yield*/, tryRequestPromiseWithBackoff(performRequest, backoffSettings, canceller.signal)];
+                            case 1:
+                                data = _a.sent();
+                                return [2 /*return*/, data];
+                            case 2:
+                                err_1 = _a.sent();
+                                throw errorSelector(err_1);
+                            case 3: return [2 /*return*/];
+                        }
+                    });
+                });
+            }
+            /**
+             * Handle minor errors encountered by a Manifest parser.
+             * @param {Array.<Error>} warnings
+             */
+            function onWarnings(warnings) {
+                for (var _i = 0, warnings_1 = warnings; _i < warnings_1.length; _i++) {
+                    var warning = warnings_1[_i];
+                    if (canceller.isUsed) {
+                        return;
+                    }
+                    emitError(warning, false);
+                }
+            }
+            /**
+             * Emit a formatted "parsed" event through `obs`.
+             * To call once the Manifest has been parsed.
+             * @param {Object} manifest
+             */
+            function emitManifestAndComplete(manifest) {
+                onWarnings(manifest.contentWarnings);
+                var parsingTime = performance.now() - parsingTimeStart;
+                log.info("MF: Manifest parsed in ".concat(parsingTime, "ms"));
+                obs.next({ type: "parsed", manifest: manifest, sendingTime: sendingTime, receivedTime: receivedTime, parsingTime: parsingTime });
+                obs.complete();
+            }
+            /**
+             * Format the given Error and emit it through `obs`.
+             * Either through a `"warning"` event, if `isFatal` is `false`, or through
+             * a fatal Observable error, if `isFatal` is set to `true`.
+             * @param {*} err
+             * @param {boolean} isFatal
+             */
+            function emitError(err, isFatal) {
+                var formattedError = formatError(err, {
                     defaultCode: "PIPELINE_PARSE_ERROR",
                     defaultReason: "Unknown error when parsing the Manifest",
                 });
-                return { type: "warning",
-                    value: formatted };
+                if (isFatal) {
+                    obs.error(formattedError);
+                }
+                else {
+                    obs.next({ type: "warning",
+                        value: formattedError });
+                }
             }
-            // 2 - send response
-            var parsingTime = performance.now() - parsingTimeStart;
-            log.info("MF: Manifest parsed in " + parsingTime + "ms");
-            return { type: "parsed",
-                manifest: parsingEvt.value.manifest,
-                sendingTime: sendingTime,
-                receivedTime: receivedTime,
-                parsingTime: parsingTime };
-        }), finalize(function () { schedulerWarnings$.complete(); })));
+        });
+    };
+    /**
+     * Construct "backoff settings" that can be used with a range of functions
+     * allowing to perform multiple request attempts
+     * @param {Function} onRetry
+     * @returns {Object}
+     */
+    ManifestFetcher.prototype._getBackoffSetting = function (onRetry) {
+        var _a = this._settings, lowLatencyMode = _a.lowLatencyMode, ogRegular = _a.maxRetryRegular, ogOffline = _a.maxRetryOffline;
+        var baseDelay = lowLatencyMode ? INITIAL_BACKOFF_DELAY_BASE.LOW_LATENCY :
+            INITIAL_BACKOFF_DELAY_BASE.REGULAR;
+        var maxDelay = lowLatencyMode ? MAX_BACKOFF_DELAY_BASE.LOW_LATENCY :
+            MAX_BACKOFF_DELAY_BASE.REGULAR;
+        var maxRetryRegular = ogRegular !== null && ogRegular !== void 0 ? ogRegular : DEFAULT_MAX_MANIFEST_REQUEST_RETRY;
+        var maxRetryOffline = ogOffline !== null && ogOffline !== void 0 ? ogOffline : DEFAULT_MAX_REQUESTS_RETRY_ON_OFFLINE;
+        return { onRetry: onRetry, baseDelay: baseDelay, maxDelay: maxDelay, maxRetryRegular: maxRetryRegular, maxRetryOffline: maxRetryOffline };
     };
     return ManifestFetcher;
 }());
 export default ManifestFetcher;
+/**
+ * Returns `true` when the returned value seems to be a Promise instance, as
+ * created by the RxPlayer.
+ * @param {*} val
+ * @returns {boolean}
+ */
+function isPromise(val) {
+    return val instanceof PPromise ||
+        val instanceof Promise;
+}

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,38 +14,11 @@
  * limitations under the License.
  */
 import { Observable } from "rxjs";
-import { ISegmentLoaderContent } from "./create_segment_loader";
-import ObservablePrioritizer from "./prioritizer";
-import { ISegmentFetcher, ISegmentFetcherEvent } 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<T> = ISegmentFetcherEvent<T> | ISegmentFetcherInterruptedEvent | IEndedTaskEvent;
-/** Oject returned by `applyPrioritizerToSegmentFetcher`. */
-export interface IPrioritizedSegmentFetcher<T> {
-    /** Create a new request for a segment with a given priority. */
-    createRequest: (content: ISegmentLoaderContent, priority?: number) => Observable<IPrioritizedSegmentFetcherEvent<T>>;
-    /** Update priority of a request created through `createRequest`. */
-    updatePriority: (observable: Observable<IPrioritizedSegmentFetcherEvent<T>>, 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,4 +26,13 @@ export interface IPrioritizedSegmentFetcher<T> {
  * @param {Object} fetcher
  * @returns {Object}
  */
-export default function applyPrioritizerToSegmentFetcher<T>(prioritizer: ObservablePrioritizer<IPrioritizedSegmentFetcherEvent<T>>, fetcher: ISegmentFetcher<T>): IPrioritizedSegmentFetcher<T>;
+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;
+}

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

@@ -171,10 +171,7 @@ var ObservablePrioritizer = /** @class */ (function () {
                     },
                 });
             };
-            newTask = { observable: pObs$,
-                priority: priority,
-                trigger: trigger,
-                subscription: null,
+            newTask = { observable: pObs$, priority: priority, trigger: trigger, subscription: null,
                 finished: false };
             if (!_this._canBeStartedNow(newTask)) {
                 _this._waitingQueue.push(newTask);