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

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

@@ -1,13 +1,14 @@
-import log from "../../../log";
-import arrayFindIndex from "../../../utils/array_find_index";
-import createCancellablePromise from "../../../utils/create_cancellable_promise";
-import TaskCanceller, { CancellationError, } from "../../../utils/task_canceller";
-var TaskPrioritizer = /** @class */ (function () {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const log_1 = require("../../../log");
+const array_find_index_1 = require("../../../utils/array_find_index");
+const create_cancellable_promise_1 = require("../../../utils/create_cancellable_promise");
+const task_canceller_1 = require("../../../utils/task_canceller");
+class TaskPrioritizer {
     /**
      * @param {Options} prioritizerOptions
      */
-    function TaskPrioritizer(_a) {
-        var prioritySteps = _a.prioritySteps;
+    constructor({ prioritySteps }) {
         this._minPendingPriority = null;
         this._waitingQueue = [];
         this._pendingTasks = [];
@@ -39,47 +40,46 @@ var TaskPrioritizer = /** @class */ (function () {
      * @param {Object} cancelSignal
      * @returns {Promise}
      */
-    TaskPrioritizer.prototype.create = function (taskFn, priority, callbacks, cancelSignal) {
-        var _this = this;
-        var newTask;
-        return createCancellablePromise(cancelSignal, function (resolve, reject) {
+    create(taskFn, priority, callbacks, cancelSignal) {
+        let newTask;
+        return (0, create_cancellable_promise_1.default)(cancelSignal, (resolve, reject) => {
             /** Function allowing to start the underlying Promise. */
-            var trigger = function () {
+            const trigger = () => {
                 if (newTask.hasEnded) {
                     return;
                 }
-                var finishTask = function () {
+                const finishTask = () => {
                     unlinkInterrupter();
-                    _this._endTask(newTask);
+                    this._endTask(newTask);
                 };
-                var onResolve = function (value) {
+                const onResolve = (value) => {
                     callbacks.beforeEnded();
                     finishTask();
                     resolve(value);
                 };
-                var onReject = function (err) {
+                const onReject = (err) => {
                     finishTask();
                     reject(err);
                 };
-                var interrupter = new TaskCanceller();
-                var unlinkInterrupter = interrupter.linkToSignal(cancelSignal);
+                const interrupter = new task_canceller_1.default();
+                const unlinkInterrupter = interrupter.linkToSignal(cancelSignal);
                 newTask.interrupter = interrupter;
-                interrupter.signal.register(function () {
+                interrupter.signal.register(() => {
                     newTask.interrupter = null;
                     if (!cancelSignal.isCancelled()) {
                         callbacks.beforeInterrupted();
                     }
                 });
-                _this._minPendingPriority = _this._minPendingPriority === null ?
+                this._minPendingPriority = this._minPendingPriority === null ?
                     newTask.priority :
-                    Math.min(_this._minPendingPriority, newTask.priority);
-                _this._pendingTasks.push(newTask);
+                    Math.min(this._minPendingPriority, newTask.priority);
+                this._pendingTasks.push(newTask);
                 newTask.taskFn(interrupter.signal)
                     .then(onResolve)
-                    .catch(function (err) {
+                    .catch((err) => {
                     if (!cancelSignal.isCancelled() &&
                         interrupter.isUsed() &&
-                        err instanceof CancellationError) {
+                        err instanceof task_canceller_1.CancellationError) {
                         return;
                     }
                     onReject(err);
@@ -87,18 +87,18 @@ var TaskPrioritizer = /** @class */ (function () {
             };
             newTask = {
                 hasEnded: false,
-                priority: priority,
-                trigger: trigger,
-                taskFn: taskFn,
+                priority,
+                trigger,
+                taskFn,
                 interrupter: null,
             };
-            if (!_this._canBeStartedNow(newTask)) {
-                _this._waitingQueue.push(newTask);
+            if (!this._canBeStartedNow(newTask)) {
+                this._waitingQueue.push(newTask);
             }
             else {
                 // We can start the task right away
                 newTask.trigger();
-                if (_this._isRunningHighPriorityTasks()) {
+                if (this._isRunningHighPriorityTasks()) {
                     // Note: we want to begin interrupting low-priority tasks just
                     // after starting the current one because the interrupting
                     // logic can call external code.
@@ -106,29 +106,29 @@ var TaskPrioritizer = /** @class */ (function () {
                     // half-state could be reached unless we're very careful.
                     // To be sure no harm is done, we put that code at the last
                     // possible position.
-                    _this._interruptCancellableTasks();
+                    this._interruptCancellableTasks();
                 }
             }
-            return function () { return _this._endTask(newTask); };
+            return () => this._endTask(newTask);
         });
-    };
-    TaskPrioritizer.prototype._endTask = function (task) {
+    }
+    _endTask(task) {
         task.hasEnded = true;
-        var waitingQueueIndex = _findTaskIndex(task.taskFn, this._waitingQueue);
+        const waitingQueueIndex = _findTaskIndex(task.taskFn, this._waitingQueue);
         if (waitingQueueIndex >= 0) {
             // If it was still waiting for its turn
             this._waitingQueue.splice(waitingQueueIndex, 1);
         }
         else {
             // remove it from pending queue if in it
-            var pendingTasksIndex = _findTaskIndex(task.taskFn, this._pendingTasks);
+            const pendingTasksIndex = _findTaskIndex(task.taskFn, this._pendingTasks);
             if (pendingTasksIndex < 0) {
                 return;
             }
             this._pendingTasks.splice(pendingTasksIndex, 1);
             if (this._pendingTasks.length > 0) {
                 if (this._minPendingPriority === task.priority) {
-                    this._minPendingPriority = Math.min.apply(Math, this._pendingTasks.map(function (t) { return t.priority; }));
+                    this._minPendingPriority = Math.min(...this._pendingTasks.map(t => t.priority));
                 }
             }
             else {
@@ -136,16 +136,16 @@ var TaskPrioritizer = /** @class */ (function () {
             }
             this._loopThroughWaitingQueue();
         }
-    };
+    }
     /**
      * Update the priority of a promise given to the TaskPrioritizer.
      * @param {Object} promise
      * @param {number} priority
      */
-    TaskPrioritizer.prototype.updatePriority = function (promise, priority) {
-        var waitingQueueIndex = _findTaskIndex(promise, this._waitingQueue);
+    updatePriority(promise, priority) {
+        const waitingQueueIndex = _findTaskIndex(promise, this._waitingQueue);
         if (waitingQueueIndex >= 0) { // If it was still waiting for its turn
-            var waitingQueueElt = this._waitingQueue[waitingQueueIndex];
+            const waitingQueueElt = this._waitingQueue[waitingQueueIndex];
             if (waitingQueueElt.priority === priority) {
                 return;
             }
@@ -175,16 +175,16 @@ var TaskPrioritizer = /** @class */ (function () {
             }
             return;
         }
-        var pendingTasksIndex = _findTaskIndex(promise, this._pendingTasks);
+        const pendingTasksIndex = _findTaskIndex(promise, this._pendingTasks);
         if (pendingTasksIndex < 0) {
-            log.warn("TP: request to update the priority of a non-existent task");
+            log_1.default.warn("TP: request to update the priority of a non-existent task");
             return;
         }
-        var task = this._pendingTasks[pendingTasksIndex];
+        const task = this._pendingTasks[pendingTasksIndex];
         if (task.priority === priority) {
             return;
         }
-        var prevPriority = task.priority;
+        const prevPriority = task.priority;
         task.priority = priority;
         if (this._minPendingPriority === null || priority < this._minPendingPriority) {
             this._minPendingPriority = priority;
@@ -194,7 +194,7 @@ var TaskPrioritizer = /** @class */ (function () {
                 this._minPendingPriority = priority;
             }
             else {
-                this._minPendingPriority = Math.min.apply(Math, this._pendingTasks.map(function (t) { return t.priority; }));
+                this._minPendingPriority = Math.min(...this._pendingTasks.map(t => t.priority));
             }
             this._loopThroughWaitingQueue();
         }
@@ -203,7 +203,7 @@ var TaskPrioritizer = /** @class */ (function () {
             // avoid re-entrancy issues
             this._interruptCancellableTasks();
         }
-    };
+    }
     /**
      * Browse the current waiting queue and start all task in it that needs to be
      * started: start the ones with the lowest priority value below
@@ -212,8 +212,8 @@ var TaskPrioritizer = /** @class */ (function () {
      * Private properties, such as `_minPendingPriority` are updated accordingly
      * while this method is called.
      */
-    TaskPrioritizer.prototype._loopThroughWaitingQueue = function () {
-        var minWaitingPriority = this._waitingQueue.reduce(function (acc, elt) {
+    _loopThroughWaitingQueue() {
+        const minWaitingPriority = this._waitingQueue.reduce((acc, elt) => {
             return acc === null || acc > elt.priority ? elt.priority :
                 acc;
         }, null);
@@ -222,26 +222,26 @@ var TaskPrioritizer = /** @class */ (function () {
                 this._minPendingPriority < minWaitingPriority)) {
             return;
         }
-        for (var i = 0; i < this._waitingQueue.length; i++) {
-            var priorityToCheck = this._minPendingPriority === null ?
+        for (let i = 0; i < this._waitingQueue.length; i++) {
+            const priorityToCheck = this._minPendingPriority === null ?
                 minWaitingPriority :
                 Math.min(this._minPendingPriority, minWaitingPriority);
-            var elt = this._waitingQueue[i];
+            const elt = this._waitingQueue[i];
             if (elt.priority <= priorityToCheck) {
                 this._findAndRunWaitingQueueTask(i);
                 i--; // previous operation should have removed that element from the
                 // the waiting queue
             }
         }
-    };
+    }
     /**
      * Interrupt and move back to the waiting queue all pending tasks that are
      * low priority (having a higher priority number than
      * `this._prioritySteps.low`).
      */
-    TaskPrioritizer.prototype._interruptCancellableTasks = function () {
-        for (var i = 0; i < this._pendingTasks.length; i++) {
-            var pendingObj = this._pendingTasks[i];
+    _interruptCancellableTasks() {
+        for (let i = 0; i < this._pendingTasks.length; i++) {
+            const pendingObj = this._pendingTasks[i];
             if (pendingObj.priority >= this._prioritySteps.low) {
                 this._interruptPendingTask(pendingObj);
                 // The previous call could have a lot of potential side-effects.
@@ -250,30 +250,30 @@ var TaskPrioritizer = /** @class */ (function () {
                 return this._interruptCancellableTasks();
             }
         }
-    };
+    }
     /**
      * Start task which is at the given index in the waiting queue.
      * The task will be removed from the waiting queue in the process.
      * @param {number} index
      */
-    TaskPrioritizer.prototype._findAndRunWaitingQueueTask = function (index) {
+    _findAndRunWaitingQueueTask(index) {
         if (index >= this._waitingQueue.length || index < 0) {
-            log.warn("TP : Tried to start a non existing task");
+            log_1.default.warn("TP : Tried to start a non existing task");
             return false;
         }
-        var task = this._waitingQueue.splice(index, 1)[0];
+        const task = this._waitingQueue.splice(index, 1)[0];
         task.trigger();
         return true;
-    };
+    }
     /**
      * Move back pending task to the waiting queue and interrupt it.
      * @param {object} task
      */
-    TaskPrioritizer.prototype._interruptPendingTask = function (task) {
+    _interruptPendingTask(task) {
         var _a;
-        var pendingTasksIndex = _findTaskIndex(task.taskFn, this._pendingTasks);
+        const pendingTasksIndex = _findTaskIndex(task.taskFn, this._pendingTasks);
         if (pendingTasksIndex < 0) {
-            log.warn("TP: Interrupting a non-existent pending task. Aborting...");
+            log_1.default.warn("TP: Interrupting a non-existent pending task. Aborting...");
             return;
         }
         // Stop task and put it back in the waiting queue
@@ -283,32 +283,31 @@ var TaskPrioritizer = /** @class */ (function () {
             this._minPendingPriority = null;
         }
         else if (this._minPendingPriority === task.priority) {
-            this._minPendingPriority = Math.min.apply(Math, this._pendingTasks.map(function (t) { return t.priority; }));
+            this._minPendingPriority = Math.min(...this._pendingTasks.map(t => t.priority));
         }
         (_a = task.interrupter) === null || _a === void 0 ? void 0 : _a.cancel(); // Interrupt at last step because it calls external code
-    };
+    }
     /**
      * Return `true` if the given task can be started immediately based on its
      * priority.
      * @param {Object} task
      * @returns {boolean}
      */
-    TaskPrioritizer.prototype._canBeStartedNow = function (task) {
+    _canBeStartedNow(task) {
         return this._minPendingPriority === null ||
             task.priority <= this._minPendingPriority;
-    };
+    }
     /**
      * Returns `true` if any running task is considered "high priority".
      * returns `false` otherwise.
      * @returns {boolean}
      */
-    TaskPrioritizer.prototype._isRunningHighPriorityTasks = function () {
+    _isRunningHighPriorityTasks() {
         return this._minPendingPriority !== null &&
             this._minPendingPriority <= this._prioritySteps.high;
-    };
-    return TaskPrioritizer;
-}());
-export default TaskPrioritizer;
+    }
+}
+exports.default = TaskPrioritizer;
 /**
  * Simple utils function allowing to find a given task function in the given
  * `queue`.
@@ -319,5 +318,5 @@ export default TaskPrioritizer;
  * @returns {number}
  */
 function _findTaskIndex(taskFn, queue) {
-    return arrayFindIndex(queue, function (elt) { return elt.taskFn === taskFn; });
+    return (0, array_find_index_1.default)(queue, (elt) => elt.taskFn === taskFn);
 }

package/dist/_esm5.processed/core/fetchers/utils/error_selector.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,19 +14,21 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import { formatError, NetworkError, RequestError, } from "../../../errors";
+Object.defineProperty(exports, "__esModule", { value: true });
+const errors_1 = require("../../../errors");
 /**
  * Generate a new error from the infos given.
  * @param {string} code
  * @param {Error} error
  * @returns {Error}
  */
-export default function errorSelector(error) {
-    if (error instanceof RequestError) {
-        return new NetworkError("PIPELINE_LOAD_ERROR", error);
+function errorSelector(error) {
+    if (error instanceof errors_1.RequestError) {
+        return new errors_1.NetworkError("PIPELINE_LOAD_ERROR", error);
     }
-    return formatError(error, {
+    return (0, errors_1.formatError)(error, {
         defaultCode: "PIPELINE_LOAD_ERROR",
         defaultReason: "Unknown error when fetching the Manifest",
     });
 }
+exports.default = errorSelector;