rx-player 4.0.0-dev.2023092900 → 4.0.0-dev.2023102700

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

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,5 +14,6 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import SegmentFetcherCreator from "./segment_fetcher_creator";
-export default SegmentFetcherCreator;
+Object.defineProperty(exports, "__esModule", { value: true });
+const segment_fetcher_creator_1 = require("./segment_fetcher_creator");
+exports.default = segment_fetcher_creator_1.default;

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

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,7 +14,8 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import log from "../../../log";
+Object.defineProperty(exports, "__esModule", { value: true });
+const log_1 = require("../../../log");
 /**
  * This function basically put in relation:
  *   - an `ISegmentFetcher`, which will be used to perform the segment requests
@@ -24,13 +26,13 @@ import log from "../../../log";
  * @param {Object} fetcher
  * @returns {Object}
  */
-export default function applyPrioritizerToSegmentFetcher(prioritizer, fetcher) {
+function applyPrioritizerToSegmentFetcher(prioritizer, fetcher) {
     /**
      * 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();
+    const taskHandlers = new WeakMap();
     return {
         /**
          * Create a Segment request with a given priority.
@@ -41,11 +43,11 @@ export default function applyPrioritizerToSegmentFetcher(prioritizer, fetcher) {
          * @param {Object} cancelSignal
          * @returns {Promise}
          */
-        createRequest: function (content, priority, callbacks, cancelSignal) {
-            var givenTask = function (innerCancelSignal) {
+        createRequest(content, priority, callbacks, cancelSignal) {
+            const givenTask = (innerCancelSignal) => {
                 return fetcher(content, callbacks, innerCancelSignal);
             };
-            var ret = prioritizer.create(givenTask, priority, callbacks, cancelSignal);
+            const ret = prioritizer.create(givenTask, priority, callbacks, cancelSignal);
             taskHandlers.set(ret, givenTask);
             return ret;
         },
@@ -55,13 +57,14 @@ export default function applyPrioritizerToSegmentFetcher(prioritizer, fetcher) {
          * @param {Promise} task - The Promise returned by `createRequest`.
          * @param {Number} priority - The new priority value.
          */
-        updatePriority: function (task, priority) {
-            var correspondingTask = taskHandlers.get(task);
+        updatePriority(task, priority) {
+            const correspondingTask = taskHandlers.get(task);
             if (correspondingTask === undefined) {
-                log.warn("Fetchers: Cannot update the priority of a request: task not found.");
+                log_1.default.warn("Fetchers: Cannot update the priority of a request: task not found.");
                 return;
             }
             prioritizer.updatePriority(correspondingTask, priority);
         },
     };
 }
+exports.default = applyPrioritizerToSegmentFetcher;

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

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,57 +14,23 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-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 (g && (g = 0, op[0] && (_ = 0)), _) 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";
-import { getLoggableSegmentId, } from "../../../manifest";
-import arrayIncludes from "../../../utils/array_includes";
-import idGenerator from "../../../utils/id_generator";
-import InitializationSegmentCache from "../../../utils/initialization_segment_cache";
-import isNullOrUndefined from "../../../utils/is_null_or_undefined";
-import getTimestamp from "../../../utils/monotonic_timestamp";
-import objectAssign from "../../../utils/object_assign";
-import { CancellationError, } from "../../../utils/task_canceller";
-import errorSelector from "../utils/error_selector";
-import { scheduleRequestWithCdns } from "../utils/schedule_request";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSegmentFetcherOptions = void 0;
+const config_1 = require("../../../config");
+const errors_1 = require("../../../errors");
+const log_1 = require("../../../log");
+const manifest_1 = require("../../../manifest");
+const array_includes_1 = require("../../../utils/array_includes");
+const id_generator_1 = require("../../../utils/id_generator");
+const initialization_segment_cache_1 = require("../../../utils/initialization_segment_cache");
+const is_null_or_undefined_1 = require("../../../utils/is_null_or_undefined");
+const monotonic_timestamp_1 = require("../../../utils/monotonic_timestamp");
+const object_assign_1 = require("../../../utils/object_assign");
+const task_canceller_1 = require("../../../utils/task_canceller");
+const error_selector_1 = require("../utils/error_selector");
+const schedule_request_1 = require("../utils/schedule_request");
 /** Allows to generate a unique identifies for each request. */
-var generateRequestID = idGenerator();
+const generateRequestID = (0, id_generator_1.default)();
 /**
  * Create an `ISegmentFetcher` object which will allow to easily fetch and parse
  * segments.
@@ -88,8 +55,8 @@ var generateRequestID = idGenerator();
  * behavior of the returned `ISegmentFetcher`.
  * @returns {Function}
  */
-export default function createSegmentFetcher(bufferType, pipeline, cdnPrioritizer, lifecycleCallbacks, options) {
-    var requestOptions = {
+function createSegmentFetcher(bufferType, pipeline, cdnPrioritizer, lifecycleCallbacks, options) {
+    const requestOptions = {
         timeout: options.requestTimeout < 0 ? undefined :
             options.requestTimeout,
     };
@@ -98,10 +65,10 @@ export default function createSegmentFetcher(bufferType, pipeline, cdnPrioritize
      * This allows to avoid doing too many requests for what are usually very
      * small files.
      */
-    var cache = arrayIncludes(["audio", "video"], bufferType) ?
-        new InitializationSegmentCache() :
+    const cache = (0, array_includes_1.default)(["audio", "video"], bufferType) ?
+        new initialization_segment_cache_1.default() :
         undefined;
-    var loadSegment = pipeline.loadSegment, parseSegment = pipeline.parseSegment;
+    const { loadSegment, parseSegment } = pipeline;
     /**
      * Fetch a specific segment.
      * @param {Object} content
@@ -109,208 +76,225 @@ export default function createSegmentFetcher(bufferType, pipeline, cdnPrioritize
      * @param {Object} cancellationSignal
      * @returns {Promise}
      */
-    return function fetchSegment(content, fetcherCallbacks, cancellationSignal) {
+    return async function fetchSegment(content, fetcherCallbacks, cancellationSignal) {
         var _a, _b, _c;
-        return __awaiter(this, void 0, void 0, function () {
-            function onCancellation() {
+        const { segment, adaptation, representation, manifest, period } = content;
+        // used by logs
+        const segmentIdString = (0, manifest_1.getLoggableSegmentId)(content);
+        const requestId = generateRequestID();
+        /**
+         * 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.
+         */
+        let 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.
+         */
+        const 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.
+         */
+        let segmentDurationAcc = 0;
+        /** Set to `true` once network metrics have been sent. */
+        let metricsSent = false;
+        /** Segment context given to the transport pipelines. */
+        const context = { segment,
+            type: adaptation.type,
+            language: adaptation.language,
+            isLive: manifest.isLive,
+            periodStart: period.start,
+            periodEnd: period.end,
+            mimeType: representation.mimeType,
+            codecs: representation.codec,
+            manifestPublishTime: manifest.publishTime };
+        const loaderCallbacks = {
+            /**
+             * Callback called when the segment loader has progress information on
+             * the request.
+             * @param {Object} info
+             */
+            onProgress(info) {
                 var _a;
                 if (requestInfo !== undefined) {
-                    return; // Request already terminated
+                    return; // request already termminated
                 }
-                log.debug("SF: Segment request cancelled", segmentIdString);
-                requestInfo = null;
-                (_a = lifecycleCallbacks.onRequestEnd) === null || _a === void 0 ? void 0 : _a.call(lifecycleCallbacks, { id: requestId });
-            }
+                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: (0, monotonic_timestamp_1.default)(),
+                        id: requestId });
+                }
+            },
             /**
-             * Call a segment loader for the given URL with the right arguments.
-             * @param {Object|null} cdnMetadata
-             * @returns {Promise}
+             * 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
              */
-            function callLoaderWithUrl(cdnMetadata) {
-                return loadSegment(cdnMetadata, context, requestOptions, cancellationSignal, loaderCallbacks);
+            onNewChunk(chunkData) {
+                fetcherCallbacks.onChunk(generateParserFunction(chunkData, true));
+            },
+        };
+        // Retrieve from cache if it exists
+        const cached = cache !== undefined ? cache.get(content) :
+            null;
+        if (cached !== null) {
+            log_1.default.debug("SF: Found wanted segment in cache", segmentIdString);
+            fetcherCallbacks.onChunk(generateParserFunction(cached, false));
+            return Promise.resolve();
+        }
+        log_1.default.debug("SF: Beginning request", segmentIdString);
+        (_a = lifecycleCallbacks.onRequestBegin) === null || _a === void 0 ? void 0 : _a.call(lifecycleCallbacks, { requestTimestamp: (0, monotonic_timestamp_1.default)(),
+            id: requestId,
+            content });
+        cancellationSignal.register(onCancellation);
+        try {
+            const res = await (0, schedule_request_1.scheduleRequestWithCdns)(content.representation.cdnMetadata, cdnPrioritizer, callLoaderWithUrl, (0, object_assign_1.default)({ onRetry }, options), cancellationSignal);
+            if (res.resultType === "segment-loaded") {
+                const loadedData = res.resultData.responseData;
+                if (cache !== undefined) {
+                    cache.add(content, res.resultData.responseData);
+                }
+                fetcherCallbacks.onChunk(generateParserFunction(loadedData, false));
             }
-            /**
-             * Generate function allowing to parse a loaded segment.
-             * @param {*} data
-             * @param {Boolean} isChunked
-             * @returns {Function}
-             */
-            function generateParserFunction(data, isChunked) {
-                parsedChunks.push(false);
-                var parsedChunkId = parsedChunks.length - 1;
-                return function parse(initTimescale) {
-                    var loaded = { data: data, isChunked: isChunked };
-                    try {
-                        var parsed = parseSegment(loaded, context, initTimescale);
-                        if (!parsedChunks[parsedChunkId]) {
-                            segmentDurationAcc = segmentDurationAcc !== undefined &&
-                                parsed.segmentType === "media" &&
-                                parsed.chunkInfos !== null &&
-                                parsed.chunkInfos.duration !== undefined ?
-                                segmentDurationAcc + parsed.chunkInfos.duration :
-                                undefined;
-                            parsedChunks[parsedChunkId] = true;
-                            sendNetworkMetricsIfAvailable();
-                        }
-                        return parsed;
-                    }
-                    catch (error) {
-                        throw formatError(error, { defaultCode: "PIPELINE_PARSE_ERROR",
-                            defaultReason: "Unknown parsing error" });
-                    }
-                };
+            else if (res.resultType === "segment-created") {
+                fetcherCallbacks.onChunk(generateParserFunction(res.resultData, false));
             }
-            /**
-             * Function called when the function request is retried.
-             * @param {*} err
-             */
-            function onRetry(err) {
-                fetcherCallbacks.onRetry(errorSelector(err));
+            log_1.default.debug("SF: Segment request ended with success", segmentIdString);
+            fetcherCallbacks.onAllChunksReceived();
+            if (res.resultType !== "segment-created") {
+                requestInfo = res.resultData;
+                sendNetworkMetricsIfAvailable();
             }
-            /**
-             * Send netork metrics if they haven't yet been sent and if all data to
-             * define them is available.
-             */
-            function sendNetworkMetricsIfAvailable() {
-                var _a;
-                if (metricsSent) {
-                    return;
+            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.
+                (_b = lifecycleCallbacks.onRequestEnd) === null || _b === void 0 ? void 0 : _b.call(lifecycleCallbacks, { id: requestId });
+            }
+            cancellationSignal.deregister(onCancellation);
+        }
+        catch (err) {
+            cancellationSignal.deregister(onCancellation);
+            requestInfo = null;
+            if (err instanceof task_canceller_1.CancellationError) {
+                log_1.default.debug("SF: Segment request aborted", segmentIdString);
+                throw err;
+            }
+            log_1.default.debug("SF: Segment request failed", segmentIdString);
+            (_c = lifecycleCallbacks.onRequestEnd) === null || _c === void 0 ? void 0 : _c.call(lifecycleCallbacks, { id: requestId });
+            throw (0, error_selector_1.default)(err);
+        }
+        function onCancellation() {
+            var _a;
+            if (requestInfo !== undefined) {
+                return; // Request already terminated
+            }
+            log_1.default.debug("SF: Segment request cancelled", segmentIdString);
+            requestInfo = null;
+            (_a = lifecycleCallbacks.onRequestEnd) === null || _a === void 0 ? void 0 : _a.call(lifecycleCallbacks, { id: requestId });
+        }
+        /**
+         * Call a segment loader for the given URL with the right arguments.
+         * @param {Object|null} cdnMetadata
+         * @returns {Promise}
+         */
+        function callLoaderWithUrl(cdnMetadata) {
+            return loadSegment(cdnMetadata, context, requestOptions, cancellationSignal, loaderCallbacks);
+        }
+        /**
+         * Generate function allowing to parse a loaded segment.
+         * @param {*} data
+         * @param {Boolean} isChunked
+         * @returns {Function}
+         */
+        function generateParserFunction(data, isChunked) {
+            parsedChunks.push(false);
+            const parsedChunkId = parsedChunks.length - 1;
+            return function parse(initTimescale) {
+                const loaded = { data, isChunked };
+                try {
+                    const parsed = parseSegment(loaded, context, initTimescale);
+                    if (!parsedChunks[parsedChunkId]) {
+                        segmentDurationAcc = segmentDurationAcc !== undefined &&
+                            parsed.segmentType === "media" &&
+                            parsed.chunkInfos !== null &&
+                            parsed.chunkInfos.duration !== undefined ?
+                            segmentDurationAcc + parsed.chunkInfos.duration :
+                            undefined;
+                        parsedChunks[parsedChunkId] = true;
+                        sendNetworkMetricsIfAvailable();
+                    }
+                    return parsed;
                 }
-                if (!isNullOrUndefined(requestInfo) &&
-                    requestInfo.size !== undefined &&
-                    requestInfo.requestDuration !== undefined &&
-                    parsedChunks.length > 0 &&
-                    parsedChunks.every(function (isParsed) { return isParsed; })) {
-                    metricsSent = true;
-                    (_a = lifecycleCallbacks.onMetrics) === null || _a === void 0 ? void 0 : _a.call(lifecycleCallbacks, {
-                        size: requestInfo.size,
-                        requestDuration: requestInfo.requestDuration,
-                        content: content,
-                        segmentDuration: segmentDurationAcc,
-                    });
+                catch (error) {
+                    throw (0, errors_1.formatError)(error, { defaultCode: "PIPELINE_PARSE_ERROR",
+                        defaultReason: "Unknown parsing error" });
                 }
+            };
+        }
+        /**
+         * Function called when the function request is retried.
+         * @param {*} err
+         */
+        function onRetry(err) {
+            fetcherCallbacks.onRetry((0, error_selector_1.default)(err));
+        }
+        /**
+         * Send netork metrics if they haven't yet been sent and if all data to
+         * define them is available.
+         */
+        function sendNetworkMetricsIfAvailable() {
+            var _a;
+            if (metricsSent) {
+                return;
             }
-            var segment, adaptation, representation, manifest, period, segmentIdString, requestId, requestInfo, parsedChunks, segmentDurationAcc, metricsSent, context, loaderCallbacks, cached, res, loadedData, err_1;
-            return __generator(this, function (_d) {
-                switch (_d.label) {
-                    case 0:
-                        segment = content.segment, adaptation = content.adaptation, representation = content.representation, manifest = content.manifest, period = content.period;
-                        segmentIdString = getLoggableSegmentId(content);
-                        requestId = generateRequestID();
-                        parsedChunks = [];
-                        segmentDurationAcc = 0;
-                        metricsSent = false;
-                        context = { segment: segment, type: adaptation.type,
-                            language: adaptation.language,
-                            isLive: manifest.isLive,
-                            periodStart: period.start,
-                            periodEnd: period.end,
-                            mimeType: representation.mimeType,
-                            codecs: representation.codec,
-                            manifestPublishTime: manifest.publishTime };
-                        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: getTimestamp(),
-                                        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: getTimestamp(),
-                            id: requestId, content: content });
-                        cancellationSignal.register(onCancellation);
-                        _d.label = 1;
-                    case 1:
-                        _d.trys.push([1, 3, , 4]);
-                        return [4 /*yield*/, scheduleRequestWithCdns(content.representation.cdnMetadata, cdnPrioritizer, 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.
-                            (_b = lifecycleCallbacks.onRequestEnd) === null || _b === void 0 ? void 0 : _b.call(lifecycleCallbacks, { id: requestId });
-                        }
-                        cancellationSignal.deregister(onCancellation);
-                        return [3 /*break*/, 4];
-                    case 3:
-                        err_1 = _d.sent();
-                        cancellationSignal.deregister(onCancellation);
-                        requestInfo = null;
-                        if (err_1 instanceof CancellationError) {
-                            log.debug("SF: Segment request aborted", segmentIdString);
-                            throw err_1;
-                        }
-                        log.debug("SF: Segment request failed", segmentIdString);
-                        (_c = lifecycleCallbacks.onRequestEnd) === null || _c === void 0 ? void 0 : _c.call(lifecycleCallbacks, { id: requestId });
-                        throw errorSelector(err_1);
-                    case 4: return [2 /*return*/];
-                }
-            });
-        });
+            if (!(0, is_null_or_undefined_1.default)(requestInfo) &&
+                requestInfo.size !== undefined &&
+                requestInfo.requestDuration !== undefined &&
+                parsedChunks.length > 0 &&
+                parsedChunks.every(isParsed => isParsed)) {
+                metricsSent = true;
+                (_a = lifecycleCallbacks.onMetrics) === null || _a === void 0 ? void 0 : _a.call(lifecycleCallbacks, {
+                    size: requestInfo.size,
+                    requestDuration: requestInfo.requestDuration,
+                    content,
+                    segmentDuration: segmentDurationAcc,
+                });
+            }
+        }
     };
 }
+exports.default = createSegmentFetcher;
 /**
  * @param {string} bufferType
  * @param {Object}
  * @returns {Object}
  */
-export function getSegmentFetcherOptions(_a) {
-    var maxRetry = _a.maxRetry, lowLatencyMode = _a.lowLatencyMode, requestTimeout = _a.requestTimeout;
-    var _b = config.getCurrent(), DEFAULT_MAX_REQUESTS_RETRY_ON_ERROR = _b.DEFAULT_MAX_REQUESTS_RETRY_ON_ERROR, DEFAULT_REQUEST_TIMEOUT = _b.DEFAULT_REQUEST_TIMEOUT, INITIAL_BACKOFF_DELAY_BASE = _b.INITIAL_BACKOFF_DELAY_BASE, MAX_BACKOFF_DELAY_BASE = _b.MAX_BACKOFF_DELAY_BASE;
+function getSegmentFetcherOptions({ maxRetry, lowLatencyMode, requestTimeout }) {
+    const { DEFAULT_MAX_REQUESTS_RETRY_ON_ERROR, DEFAULT_REQUEST_TIMEOUT, INITIAL_BACKOFF_DELAY_BASE, MAX_BACKOFF_DELAY_BASE } = config_1.default.getCurrent();
     return { maxRetry: maxRetry !== null && maxRetry !== void 0 ? maxRetry : DEFAULT_MAX_REQUESTS_RETRY_ON_ERROR,
         baseDelay: lowLatencyMode ? INITIAL_BACKOFF_DELAY_BASE.LOW_LATENCY :
             INITIAL_BACKOFF_DELAY_BASE.REGULAR,
         maxDelay: lowLatencyMode ? MAX_BACKOFF_DELAY_BASE.LOW_LATENCY :
             MAX_BACKOFF_DELAY_BASE.REGULAR,
-        requestTimeout: isNullOrUndefined(requestTimeout) ? DEFAULT_REQUEST_TIMEOUT :
+        requestTimeout: (0, is_null_or_undefined_1.default)(requestTimeout) ? DEFAULT_REQUEST_TIMEOUT :
             requestTimeout };
 }
+exports.getSegmentFetcherOptions = getSegmentFetcherOptions;

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

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,26 +14,27 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import config from "../../../config";
-import CdnPrioritizer from "../cdn_prioritizer";
-import applyPrioritizerToSegmentFetcher from "./prioritized_segment_fetcher";
-import createSegmentFetcher, { getSegmentFetcherOptions, } from "./segment_fetcher";
-import TaskPrioritizer from "./task_prioritizer";
+Object.defineProperty(exports, "__esModule", { value: true });
+const config_1 = require("../../../config");
+const cdn_prioritizer_1 = require("../cdn_prioritizer");
+const prioritized_segment_fetcher_1 = require("./prioritized_segment_fetcher");
+const segment_fetcher_1 = require("./segment_fetcher");
+const task_prioritizer_1 = require("./task_prioritizer");
 /**
  * Interact with the transport pipelines to download segments with the right
  * priority.
  *
  * @class SegmentFetcherCreator
  */
-var SegmentFetcherCreator = /** @class */ (function () {
+class SegmentFetcherCreator {
     /**
      * @param {Object} transport
      */
-    function SegmentFetcherCreator(transport, options, cancelSignal) {
-        var cdnPrioritizer = new CdnPrioritizer(cancelSignal);
-        var _a = config.getCurrent(), MIN_CANCELABLE_PRIORITY = _a.MIN_CANCELABLE_PRIORITY, MAX_HIGH_PRIORITY_LEVEL = _a.MAX_HIGH_PRIORITY_LEVEL;
+    constructor(transport, options, cancelSignal) {
+        const cdnPrioritizer = new cdn_prioritizer_1.default(cancelSignal);
+        const { MIN_CANCELABLE_PRIORITY, MAX_HIGH_PRIORITY_LEVEL } = config_1.default.getCurrent();
         this._transport = transport;
-        this._prioritizer = new TaskPrioritizer({
+        this._prioritizer = new task_prioritizer_1.default({
             prioritySteps: { high: MAX_HIGH_PRIORITY_LEVEL,
                 low: MIN_CANCELABLE_PRIORITY },
         });
@@ -46,13 +48,12 @@ var SegmentFetcherCreator = /** @class */ (function () {
      * @param {Object} callbacks
      * @returns {Object}
      */
-    SegmentFetcherCreator.prototype.createSegmentFetcher = function (bufferType, callbacks) {
-        var backoffOptions = getSegmentFetcherOptions(this._backoffOptions);
-        var pipelines = this._transport[bufferType];
+    createSegmentFetcher(bufferType, callbacks) {
+        const backoffOptions = (0, segment_fetcher_1.getSegmentFetcherOptions)(this._backoffOptions);
+        const pipelines = this._transport[bufferType];
         // Types are very complicated here as they are per-type of buffer.
-        var segmentFetcher = createSegmentFetcher(bufferType, pipelines, this._cdnPrioritizer, callbacks, backoffOptions);
-        return applyPrioritizerToSegmentFetcher(this._prioritizer, segmentFetcher);
-    };
-    return SegmentFetcherCreator;
-}());
-export default SegmentFetcherCreator;
+        const segmentFetcher = (0, segment_fetcher_1.default)(bufferType, pipelines, this._cdnPrioritizer, callbacks, backoffOptions);
+        return (0, prioritized_segment_fetcher_1.default)(this._prioritizer, segmentFetcher);
+    }
+}
+exports.default = SegmentFetcherCreator;