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

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

@@ -13,12 +13,11 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { map, } from "rxjs";
 import log from "../../../log";
 /**
  * This function basically put in relation:
  *   - an `ISegmentFetcher`, which will be used to perform the segment requests
- *   - a prioritizer, which will handle the priority of a segment request
+ *   - a `TaskPrioritizer`, which will handle the priority of a segment request
  *
  * and returns functions to fetch segments with a given priority.
  * @param {Object} prioritizer
@@ -26,7 +25,11 @@ import log from "../../../log";
  * @returns {Object}
  */
 export default function applyPrioritizerToSegmentFetcher(prioritizer, fetcher) {
-    /** Map returned task to the task as returned by the `ObservablePrioritizer`. */
+    /**
+     * Map Promises returned by the `createRequest` method into the actual tasks
+     * used by the `TaskPrioritizer`, allowing to update task priorities just by
+     * using the Promise.
+     */
     var taskHandlers = new WeakMap();
     return {
         /**
@@ -34,26 +37,25 @@ export default function applyPrioritizerToSegmentFetcher(prioritizer, fetcher) {
          * @param {Object} content - content to request
          * @param {Number} priority - priority at which the content should be requested.
          * Lower number == higher priority.
-         * @returns {Observable}
+         * @returns {Promise}
          */
-        createRequest: function (content, priority) {
+        createRequest: function (content, priority, callbacks, cancelSignal) {
             if (priority === void 0) { priority = 0; }
-            var task = prioritizer.create(fetcher(content), priority);
-            var flattenTask = task.pipe(map(function (evt) {
-                return evt.type === "data" ? evt.value :
-                    evt;
-            }));
-            taskHandlers.set(flattenTask, task);
-            return flattenTask;
+            var givenTask = function (innerCancelSignal) {
+                return fetcher(content, callbacks, innerCancelSignal);
+            };
+            var ret = prioritizer.create(givenTask, priority, callbacks, cancelSignal);
+            taskHandlers.set(ret, givenTask);
+            return ret;
         },
         /**
          * Update the priority of a pending request, created through
          * `createRequest`.
-         * @param {Observable} observable - The Observable returned by `createRequest`.
+         * @param {Promise} task - The Promise returned by `createRequest`.
          * @param {Number} priority - The new priority value.
          */
-        updatePriority: function (observable, priority) {
-            var correspondingTask = taskHandlers.get(observable);
+        updatePriority: function (task, priority) {
+            var correspondingTask = taskHandlers.get(task);
             if (correspondingTask === undefined) {
                 log.warn("Fetchers: Cannot update the priority of a request: task not found.");
                 return;

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

@@ -13,10 +13,10 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { Observable } from "rxjs";
 import Manifest, { Adaptation, ISegment, Period, Representation } from "../../../manifest";
 import { IPlayerError } from "../../../public_types";
 import { ISegmentParserParsedInitChunk, ISegmentParserParsedMediaChunk, ISegmentPipeline } from "../../../transports";
+import { CancellationSignal } from "../../../utils/task_canceller";
 import { IMetricsCallbackPayload, IRequestBeginCallbackPayload, IRequestEndCallbackPayload, IRequestProgressCallbackPayload } from "../../adaptive";
 import { IBufferType } from "../../segment_buffers";
 /**
@@ -27,40 +27,42 @@ import { IBufferType } from "../../segment_buffers";
  *
  * @param {string} bufferType
  * @param {Object} pipeline
- * @param {Object} callbacks
+ * @param {Object} lifecycleCallbacks
  * @param {Object} options
  * @returns {Function}
  */
-export default function createSegmentFetcher<TLoadedFormat, TSegmentDataType>(bufferType: IBufferType, pipeline: ISegmentPipeline<TLoadedFormat, TSegmentDataType>, callbacks: ISegmentFetcherCreatorCallbacks, options: ISegmentFetcherOptions): ISegmentFetcher<TSegmentDataType>;
-export declare type ISegmentFetcher<TSegmentDataType> = (content: ISegmentLoaderContent) => Observable<ISegmentFetcherEvent<TSegmentDataType>>;
-/** Event sent by the SegmentFetcher when fetching a segment. */
-export declare type ISegmentFetcherEvent<TSegmentDataType> = ISegmentFetcherChunkEvent<TSegmentDataType> | ISegmentFetcherChunkCompleteEvent | ISegmentFetcherRetry;
+export default function createSegmentFetcher<TLoadedFormat, TSegmentDataType>(bufferType: IBufferType, pipeline: ISegmentPipeline<TLoadedFormat, TSegmentDataType>, lifecycleCallbacks: ISegmentFetcherLifecycleCallbacks, options: ISegmentFetcherOptions): ISegmentFetcher<TSegmentDataType>;
 /**
- * Event sent when a new "chunk" of the segment is available.
- * A segment can contain n chunk(s) for n >= 0.
+ * Defines the `ISegmentFetcher` function which allows to load a single segment.
+ *
+ * Loaded data is entirely communicated through callbacks present in the
+ * `callbacks` arguments.
+ *
+ * The returned Promise only gives an indication of if the request ended with
+ * success or on error.
  */
-export interface ISegmentFetcherChunkEvent<TSegmentDataType> {
-    type: "chunk";
-    /** Parse the downloaded chunk. */
-    /**
-     * Parse the downloaded chunk.
-     *
-     * Take in argument the timescale value that might have been obtained by
-     * parsing an initialization segment from the same Representation.
-     * Can be left to `undefined` if unknown or inexistant, segment parsers should
-     * be resilient and still work without that information.
-     *
-     * @param {number} initTimescale
-     * @returns {Object}
-     */
-    parse(initTimescale?: number): ISegmentParserParsedInitChunk<TSegmentDataType> | ISegmentParserParsedMediaChunk<TSegmentDataType>;
-}
+export declare type ISegmentFetcher<TSegmentDataType> = (
+/** Information on the segment wanted. */
+content: ISegmentLoaderContent, 
+/** Callbacks the `ISegmentFetcher` will call as it loads the data. */
+callbacks: ISegmentFetcherCallbacks<TSegmentDataType>, 
+/** CancellationSignal allowing to cancel the request. */
+cancellationSignal: CancellationSignal) => Promise<void>;
 /**
- * Event sent when all "chunk" of the segments have been communicated through
- * `ISegmentFetcherChunkEvent` events.
+ * Callbacks given to an `ISegmentFetcher` allowing to be notified on its
+ * inner request's various events.
  */
-export interface ISegmentFetcherChunkCompleteEvent {
-    type: "chunk-complete";
+export interface ISegmentFetcherCallbacks<TSegmentDataType> {
+    /** Called when a decodable chunk of the whole segment is available. */
+    onChunk(parse: (initTimescale: number | undefined) => ISegmentParserParsedInitChunk<TSegmentDataType> | ISegmentParserParsedMediaChunk<TSegmentDataType>): void;
+    /**
+     * Callback called when all decodable chunks of the loaded segment have been
+     * communicated through the `onChunk` callback.
+     */
+    onAllChunksReceived(): void;
+    /**
+     * Callback called when the segment request has to restart from scratch. */
+    onRetry(error: IPlayerError): void;
 }
 /** Content used by the segment loader as a context to load a new segment. */
 export interface ISegmentLoaderContent {
@@ -71,19 +73,10 @@ export interface ISegmentLoaderContent {
     segment: ISegment;
 }
 /**
- * An Error happened while loading which led to a retry.
- * The request is retried from scratch.
- */
-export interface ISegmentFetcherRetry {
-    type: "retry";
-    value: IPlayerError;
-}
-/**
- * Callbacks that can be bound when creating an `ISegmentFetcher`.
- * Those allows to be notified of an `ISegmentFetcher` various lifecycles and of
- * network information.
+ * Callbacks given when creating an `ISegmentFetcher`, allowing to be notified
+ * on high-level metadata about performed requests.
  */
-export interface ISegmentFetcherCreatorCallbacks {
+export interface ISegmentFetcherLifecycleCallbacks {
     /** Called when a segment request begins. */
     onRequestBegin?: (arg: IRequestBeginCallbackPayload) => void;
     /** Called when progress information is available on a pending segment request. */

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

@@ -13,7 +13,42 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { Observable } from "rxjs";
+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 config from "../../../config";
 import { formatError } from "../../../errors";
 import log from "../../../log";
@@ -23,9 +58,10 @@ import idGenerator from "../../../utils/id_generator";
 import InitializationSegmentCache from "../../../utils/initialization_segment_cache";
 import isNullOrUndefined from "../../../utils/is_null_or_undefined";
 import objectAssign from "../../../utils/object_assign";
-import TaskCanceller from "../../../utils/task_canceller";
+import { CancellationError, } from "../../../utils/task_canceller";
 import errorSelector from "../utils/error_selector";
 import { tryURLsWithBackoff } from "../utils/try_urls_with_backoff";
+/** Allows to generate a unique identifies for each request. */
 var generateRequestID = idGenerator();
 /**
  * Create an `ISegmentFetcher` object which will allow to easily fetch and parse
@@ -35,11 +71,11 @@ var generateRequestID = idGenerator();
  *
  * @param {string} bufferType
  * @param {Object} pipeline
- * @param {Object} callbacks
+ * @param {Object} lifecycleCallbacks
  * @param {Object} options
  * @returns {Function}
  */
-export default function createSegmentFetcher(bufferType, pipeline, callbacks, options) {
+export default function createSegmentFetcher(bufferType, pipeline, lifecycleCallbacks, options) {
     var requestOptions = {
         timeout: options.requestTimeout < 0 ? undefined :
             options.requestTimeout,
@@ -55,158 +91,20 @@ export default function createSegmentFetcher(bufferType, pipeline, callbacks, op
     var loadSegment = pipeline.loadSegment, parseSegment = pipeline.parseSegment;
     /**
      * Fetch a specific segment.
-     *
-     * This function returns an Observable which will fetch segments on
-     * subscription.
-     * If the corresponding request fails, it may retry it based on the given
-     * options.
-     *
-     * This Observable will emit various events during that request lifecycle and
-     * throw if the segment request(s) (including potential retries) fail.
-     * The Observable will automatically complete once no events are left to be
-     * sent.
      * @param {Object} content
-     * @returns {Observable}
+     * @param {Object} fetcherCallbacks
+     * @param {Object} cancellationSignal
+     * @returns {Promise}
      */
-    return function fetchSegment(content) {
-        var segment = content.segment;
-        // used by logs
-        var segmentIdString = getLoggableSegmentId(content);
-        return new Observable(function (obs) {
-            var _a, _b;
-            var requestId = generateRequestID();
-            var canceller = new TaskCanceller();
-            /**
-             * If the request succeeded, set to the corresponding
-             * `IChunkCompleteInformation` object.
-             * For any other completion cases: if the request either failed, was
-             * cancelled or just if no request was needed, set to `null`.
-             *
-             * Stays to `undefined` when the request is still pending.
-             */
-            var requestInfo;
-            /**
-             * Array containing one entry per loaded chunk, in chronological order.
-             * The boolean indicates if the chunk has been parsed at least once.
-             *
-             * This is used to know when all loaded chunks have been parsed, which
-             * can be useful to e.g. construct metrics about the loaded segment.
-             */
-            var parsedChunks = [];
-            /**
-             * Addition of the duration of each encountered and parsed chunks.
-             * Allows to have an idea of the real duration of the full segment once
-             * all chunks have been parsed.
-             *
-             * `undefined` if at least one of the parsed chunks has unknown duration.
-             */
-            var segmentDurationAcc = 0;
-            /** Set to `true` once network metrics have been sent. */
-            var metricsSent = false;
-            var loaderCallbacks = {
-                /**
-                 * Callback called when the segment loader has progress information on
-                 * the request.
-                 * @param {Object} info
-                 */
-                onProgress: function (info) {
-                    var _a;
-                    if (requestInfo !== undefined) {
-                        return; // Request already terminated
-                    }
-                    if (info.totalSize !== undefined && info.size < info.totalSize) {
-                        (_a = callbacks.onProgress) === null || _a === void 0 ? void 0 : _a.call(callbacks, { duration: info.duration,
-                            size: info.size,
-                            totalSize: info.totalSize,
-                            timestamp: performance.now(),
-                            id: requestId });
-                    }
-                },
-                /**
-                 * Callback called when the segment is communicated by the loader
-                 * through decodable sub-segment(s) called chunk(s), with a chunk in
-                 * argument.
-                 * @param {*} chunkData
-                 */
-                onNewChunk: function (chunkData) {
-                    obs.next({ type: "chunk",
-                        parse: generateParserFunction(chunkData, true) });
-                },
-            };
-            // Retrieve from cache if it exists
-            var cached = cache !== undefined ? cache.get(content) :
-                null;
-            if (cached !== null) {
-                log.debug("SF: Found wanted segment in cache", segmentIdString);
-                obs.next({ type: "chunk",
-                    parse: generateParserFunction(cached, false) });
-                obs.next({ type: "chunk-complete" });
-                obs.complete();
-                return undefined;
-            }
-            log.debug("SF: Beginning request", segmentIdString);
-            (_a = callbacks.onRequestBegin) === null || _a === void 0 ? void 0 : _a.call(callbacks, { requestTimestamp: performance.now(),
-                id: requestId, content: content });
-            tryURLsWithBackoff((_b = segment.mediaURLs) !== null && _b !== void 0 ? _b : [null], callLoaderWithUrl, objectAssign({ onRetry: onRetry }, options), canceller.signal)
-                .then(function (res) {
-                var _a;
-                log.debug("SF: Segment request ended with success", segmentIdString);
-                if (res.resultType === "segment-loaded") {
-                    var loadedData = res.resultData.responseData;
-                    if (cache !== undefined) {
-                        cache.add(content, res.resultData.responseData);
-                    }
-                    obs.next({ type: "chunk",
-                        parse: generateParserFunction(loadedData, false) });
-                }
-                else if (res.resultType === "segment-created") {
-                    obs.next({ type: "chunk",
-                        parse: generateParserFunction(res.resultData, false) });
-                }
-                log.debug("SF: Segment request ended with success", segmentIdString);
-                obs.next({ type: "chunk-complete" });
-                if (res.resultType !== "segment-created") {
-                    requestInfo = res.resultData;
-                    sendNetworkMetricsIfAvailable();
-                }
-                else {
-                    requestInfo = null;
-                }
-                if (!canceller.isUsed) {
-                    // The current Observable could have been canceled as a result of one
-                    // of the previous `next` calls. In that case, we don't want to send
-                    // a "requestEnd" again as it has already been sent on cancellation.
-                    //
-                    // Note that we only perform this check for `onRequestEnd` on
-                    // purpose. Observable's events should have been ignored by RxJS if
-                    // the Observable has already been canceled and we don't care if
-                    // `"metrics"` is sent there.
-                    (_a = callbacks.onRequestEnd) === null || _a === void 0 ? void 0 : _a.call(callbacks, { id: requestId });
-                }
-                obs.complete();
-            })
-                .catch(function (err) {
-                log.debug("SF: Segment request failed", segmentIdString);
-                requestInfo = null;
-                obs.error(errorSelector(err));
-            });
-            return function () {
-                var _a;
-                if (requestInfo !== undefined) {
-                    return; // Request already terminated
-                }
-                log.debug("SF: Segment request cancelled", segmentIdString);
-                requestInfo = null;
-                canceller.cancel();
-                (_a = callbacks.onRequestEnd) === null || _a === void 0 ? void 0 : _a.call(callbacks, { id: requestId });
-            };
+    return function fetchSegment(content, fetcherCallbacks, cancellationSignal) {
+        var _a, _b, _c;
+        return __awaiter(this, void 0, void 0, function () {
             /**
              * Call a segment loader for the given URL with the right arguments.
              * @param {string|null} url
-             * @param {Object} cancellationSignal
              * @returns {Promise}
              */
-            function callLoaderWithUrl(url, cancellationSignal) {
+            function callLoaderWithUrl(url) {
                 return loadSegment(url, content, requestOptions, cancellationSignal, loaderCallbacks);
             }
             /**
@@ -245,8 +143,7 @@ export default function createSegmentFetcher(bufferType, pipeline, callbacks, op
              * @param {*} err
              */
             function onRetry(err) {
-                obs.next({ type: "retry",
-                    value: errorSelector(err) });
+                fetcherCallbacks.onRetry(errorSelector(err));
             }
             /**
              * Send netork metrics if they haven't yet been sent and if all data to
@@ -263,10 +160,116 @@ export default function createSegmentFetcher(bufferType, pipeline, callbacks, op
                     parsedChunks.length > 0 &&
                     parsedChunks.every(function (isParsed) { return isParsed; })) {
                     metricsSent = true;
-                    (_a = callbacks.onMetrics) === null || _a === void 0 ? void 0 : _a.call(callbacks, { size: requestInfo.size,
-                        requestDuration: requestInfo.requestDuration, content: content, segmentDuration: segmentDurationAcc });
+                    (_a = lifecycleCallbacks.onMetrics) === null || _a === void 0 ? void 0 : _a.call(lifecycleCallbacks, {
+                        size: requestInfo.size,
+                        requestDuration: requestInfo.requestDuration,
+                        content: content,
+                        segmentDuration: segmentDurationAcc,
+                    });
                 }
             }
+            var segment, segmentIdString, requestId, requestInfo, parsedChunks, segmentDurationAcc, metricsSent, loaderCallbacks, cached, res, loadedData, err_1;
+            return __generator(this, function (_d) {
+                switch (_d.label) {
+                    case 0:
+                        segment = content.segment;
+                        segmentIdString = getLoggableSegmentId(content);
+                        requestId = generateRequestID();
+                        parsedChunks = [];
+                        segmentDurationAcc = 0;
+                        metricsSent = false;
+                        loaderCallbacks = {
+                            /**
+                             * Callback called when the segment loader has progress information on
+                             * the request.
+                             * @param {Object} info
+                             */
+                            onProgress: function (info) {
+                                var _a;
+                                if (requestInfo !== undefined) {
+                                    return; // request already termminated
+                                }
+                                if (info.totalSize !== undefined && info.size < info.totalSize) {
+                                    (_a = lifecycleCallbacks.onProgress) === null || _a === void 0 ? void 0 : _a.call(lifecycleCallbacks, { duration: info.duration,
+                                        size: info.size,
+                                        totalSize: info.totalSize,
+                                        timestamp: performance.now(),
+                                        id: requestId });
+                                }
+                            },
+                            /**
+                             * Callback called when the segment is communicated by the loader
+                             * through decodable sub-segment(s) called chunk(s), with a chunk in
+                             * argument.
+                             * @param {*} chunkData
+                             */
+                            onNewChunk: function (chunkData) {
+                                fetcherCallbacks.onChunk(generateParserFunction(chunkData, true));
+                            },
+                        };
+                        cached = cache !== undefined ? cache.get(content) :
+                            null;
+                        if (cached !== null) {
+                            log.debug("SF: Found wanted segment in cache", segmentIdString);
+                            fetcherCallbacks.onChunk(generateParserFunction(cached, false));
+                            return [2 /*return*/, Promise.resolve()];
+                        }
+                        log.debug("SF: Beginning request", segmentIdString);
+                        (_a = lifecycleCallbacks.onRequestBegin) === null || _a === void 0 ? void 0 : _a.call(lifecycleCallbacks, { requestTimestamp: performance.now(),
+                            id: requestId, content: content });
+                        cancellationSignal.register(function () {
+                            var _a;
+                            if (requestInfo !== undefined) {
+                                return; // Request already terminated
+                            }
+                            log.debug("SF: Segment request cancelled", segmentIdString);
+                            requestInfo = null;
+                            (_a = lifecycleCallbacks.onRequestEnd) === null || _a === void 0 ? void 0 : _a.call(lifecycleCallbacks, { id: requestId });
+                        });
+                        _d.label = 1;
+                    case 1:
+                        _d.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, tryURLsWithBackoff((_b = segment.mediaURLs) !== null && _b !== void 0 ? _b : [null], callLoaderWithUrl, objectAssign({ onRetry: onRetry }, options), cancellationSignal)];
+                    case 2:
+                        res = _d.sent();
+                        if (res.resultType === "segment-loaded") {
+                            loadedData = res.resultData.responseData;
+                            if (cache !== undefined) {
+                                cache.add(content, res.resultData.responseData);
+                            }
+                            fetcherCallbacks.onChunk(generateParserFunction(loadedData, false));
+                        }
+                        else if (res.resultType === "segment-created") {
+                            fetcherCallbacks.onChunk(generateParserFunction(res.resultData, false));
+                        }
+                        log.debug("SF: Segment request ended with success", segmentIdString);
+                        fetcherCallbacks.onAllChunksReceived();
+                        if (res.resultType !== "segment-created") {
+                            requestInfo = res.resultData;
+                            sendNetworkMetricsIfAvailable();
+                        }
+                        else {
+                            requestInfo = null;
+                        }
+                        if (!cancellationSignal.isCancelled) {
+                            // The current task could have been canceled as a result of one
+                            // of the previous callbacks call. In that case, we don't want to send
+                            // a "requestEnd" again as it has already been sent on cancellation.
+                            (_c = lifecycleCallbacks.onRequestEnd) === null || _c === void 0 ? void 0 : _c.call(lifecycleCallbacks, { id: requestId });
+                        }
+                        return [3 /*break*/, 4];
+                    case 3:
+                        err_1 = _d.sent();
+                        requestInfo = null;
+                        if (err_1 instanceof CancellationError) {
+                            log.debug("SF: Segment request aborted", segmentIdString);
+                            throw err_1;
+                        }
+                        log.debug("SF: Segment request failed", segmentIdString);
+                        throw errorSelector(err_1);
+                    case 4: return [2 /*return*/];
+                }
+            });
         });
     };
 }

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

@@ -16,7 +16,7 @@
 import { ITransportPipelines } from "../../../transports";
 import { IBufferType } from "../../segment_buffers";
 import { IPrioritizedSegmentFetcher } from "./prioritized_segment_fetcher";
-import { ISegmentFetcherCreatorCallbacks } from "./segment_fetcher";
+import { ISegmentFetcherLifecycleCallbacks } from "./segment_fetcher";
 /**
  * Interact with the transport pipelines to download segments with the right
  * priority.
@@ -54,7 +54,7 @@ export default class SegmentFetcherCreator {
      */
     private readonly _transport;
     /**
-     * `ObservablePrioritizer` linked to this SegmentFetcherCreator.
+     * `TaskPrioritizer` linked to this SegmentFetcherCreator.
      *
      * Note: this is typed as `any` because segment loaders / parsers can use
      * different types depending on the type of buffer. We could maybe be smarter
@@ -78,7 +78,7 @@ export default class SegmentFetcherCreator {
      * @param {Object} callbacks
      * @returns {Object}
      */
-    createSegmentFetcher(bufferType: IBufferType, callbacks: ISegmentFetcherCreatorCallbacks): IPrioritizedSegmentFetcher<unknown>;
+    createSegmentFetcher(bufferType: IBufferType, callbacks: ISegmentFetcherLifecycleCallbacks): IPrioritizedSegmentFetcher<unknown>;
 }
 /** Options used by the `SegmentFetcherCreator`. */
 export interface ISegmentFetcherCreatorBackoffOptions {

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

@@ -15,8 +15,8 @@
  */
 import config from "../../../config";
 import applyPrioritizerToSegmentFetcher from "./prioritized_segment_fetcher";
-import ObservablePrioritizer from "./prioritizer";
 import createSegmentFetcher, { getSegmentFetcherOptions, } from "./segment_fetcher";
+import TaskPrioritizer from "./task_prioritizer";
 /**
  * Interact with the transport pipelines to download segments with the right
  * priority.
@@ -54,7 +54,7 @@ var SegmentFetcherCreator = /** @class */ (function () {
     function SegmentFetcherCreator(transport, options) {
         var _a = config.getCurrent(), MIN_CANCELABLE_PRIORITY = _a.MIN_CANCELABLE_PRIORITY, MAX_HIGH_PRIORITY_LEVEL = _a.MAX_HIGH_PRIORITY_LEVEL;
         this._transport = transport;
-        this._prioritizer = new ObservablePrioritizer({
+        this._prioritizer = new TaskPrioritizer({
             prioritySteps: { high: MAX_HIGH_PRIORITY_LEVEL,
                 low: MIN_CANCELABLE_PRIORITY },
         });