rx-player 4.4.1 → 4.5.0-dev.2026012301

package/dist/commonjs/core/fetchers/segment/task_prioritizer.d.ts

@@ -1,155 +0,0 @@
-import type { CancellationSignal } from "../../../utils/task_canceller";
-/**
- * Utilitary class which allows to perform multiple tasks at once each with an
- * associated priority.
- *
- * This class will then schedule the given tasks in the right order based on the
- * priorities.
- *
- * @class TaskPrioritizer
- */
-export default class TaskPrioritizer<T> {
-    /**
-     * Priority of the most prioritary task currently running.
-     * `null` if no task is currently running.
-     */
-    private _minPendingPriority;
-    /** Queue of tasks currently waiting for more prioritary ones to finish. */
-    private _waitingQueue;
-    /** Tasks currently pending.  */
-    private _pendingTasks;
-    /** @see IPrioritizerPrioritySteps */
-    private _prioritySteps;
-    /**
-     * @param {Options} prioritizerOptions
-     */
-    constructor({ prioritySteps }: IPrioritizerOptions);
-    /**
-     * Create a priorized Promise from a base task.
-     *
-     * This task will immediately have its priority compared to all the
-     * already-running ones created from this class.
-     *
-     * Only if this number is inferior or equal to the priority of the
-     * minimum priority number of all currently-running tasks  will it be
-     * immediately started.
-     * In the opposite case, we will wait for higher-priority tasks to
-     * finish before starting it.
-     *
-     * Note that while this task is waiting for its turn, it is possible
-     * to update its property through the updatePriority method, by providing
-     * the task again and its new priority number.
-     *
-     * @param {Function} taskFn
-     * @param {number} priority
-     * @param {Object} callbacks
-     * @param {Object} cancelSignal
-     * @returns {Promise}
-     */
-    create(taskFn: ITaskFn<T>, priority: number, callbacks: ITaskPrioritizerCallbacks, cancelSignal: CancellationSignal): Promise<T>;
-    private _endTask;
-    /**
-     * Update the priority of a promise given to the TaskPrioritizer.
-     * @param {Object} promise
-     * @param {number} priority
-     */
-    updatePriority(promise: ITaskFn<T>, priority: number): void;
-    /**
-     * 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
-     * `_minPendingPriority`.
-     *
-     * Private properties, such as `_minPendingPriority` are updated accordingly
-     * while this method is called.
-     */
-    private _loopThroughWaitingQueue;
-    /**
-     * Interrupt and move back to the waiting queue all pending tasks that are
-     * low priority (having a higher priority number than
-     * `this._prioritySteps.low`).
-     */
-    private _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
-     */
-    private _findAndRunWaitingQueueTask;
-    /**
-     * Move back pending task to the waiting queue and interrupt it.
-     * @param {object} task
-     */
-    private _interruptPendingTask;
-    /**
-     * Return `true` if the given task can be started immediately based on its
-     * priority.
-     * @param {Object} task
-     * @returns {boolean}
-     */
-    private _canBeStartedNow;
-    /**
-     * Returns `true` if any running task is considered "high priority".
-     * returns `false` otherwise.
-     * @returns {boolean}
-     */
-    private _isRunningHighPriorityTasks;
-}
-/**
- * Task function as given to the TaskPrioritizer.
- * The `CancellationSignal` given as argument should be used to directly
- * interrupt the task.
- *
- * A same task might be re-run multiple times.
- */
-export type ITaskFn<T> = (cancellationSignal: CancellationSignal) => Promise<T>;
-/** Options to give to the `TaskPrioritizer`. */
-export interface IPrioritizerOptions {
-    /** @see IPrioritizerPrioritySteps */
-    prioritySteps: IPrioritizerPrioritySteps;
-}
-/**
- * Define both the `low` and `high` priority steps:
- *
- *   - Any task with a priority number that is lower or equal to the
- *     `high` value will be a task with high priority.
- *
- *     When tasks with high priorities are scheduled, they immediately
- *     abort pending tasks with low priorities (which will have then to
- *     wait until all higher-priority task have ended before re-starting).
- *
- *   - Any task with a priority number that is higher or equal to the
- *     `low` value will be a task with low priority.
- *
- *     Pending tasks with low priorities have the added particularity*
- *     of being aborted as soon as a high priority task is scheduled.
- *
- *     * Other pending tasks are not aborted when a higher-priority
- *     task 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;
-}
-/**
- * Callbacks called by the `TaskPrioritizer` on various events associated to a
- * single task.
- */
-export interface ITaskPrioritizerCallbacks {
-    /**
-     * Callback called just before the `TaskPrioritizer` temporarily cancels
-     * a task, to prioritize higher-priority tasks.
-     *
-     * Interrupted tasks are restarted from scratch at a later time.
-     */
-    beforeInterrupted(): void;
-    /**
-     * Callback called when the task ended just before the `TaskPrioritizer`
-     * chooses the next task(s) to run.
-     *
-     * You can use this callback to add yet other tasks just in time before the
-     * `TaskPrioritizer` chooses the next one.
-     */
-    beforeEnded(): void;
-}
-//# sourceMappingURL=task_prioritizer.d.ts.map

package/dist/commonjs/core/fetchers/segment/task_prioritizer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"task_prioritizer.d.ts","sourceRoot":"","sources":["../../../../../src/core/fetchers/segment/task_prioritizer.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,+BAA+B,CAAC;AAGxE;;;;;;;;GAQG;AACH,MAAM,CAAC,OAAO,OAAO,eAAe,CAAC,CAAC;IACpC;;;OAGG;IACH,OAAO,CAAC,mBAAmB,CAAgB;IAC3C,2EAA2E;IAC3E,OAAO,CAAC,aAAa,CAA6B;IAClD,gCAAgC;IAChC,OAAO,CAAC,aAAa,CAA6B;IAClD,qCAAqC;IACrC,OAAO,CAAC,cAAc,CAA4B;IAElD;;OAEG;gBACS,EAAE,aAAa,EAAE,EAAE,mBAAmB;IAclD;;;;;;;;;;;;;;;;;;;;;OAqBG;IACI,MAAM,CACX,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC,EAClB,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,yBAAyB,EACpC,YAAY,EAAE,kBAAkB,GAC/B,OAAO,CAAC,CAAC,CAAC;IAoFb,OAAO,CAAC,QAAQ;IA2BhB;;;;OAIG;IACI,cAAc,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI;IAwElE;;;;;;;OAOG;IACH,OAAO,CAAC,wBAAwB;IAwBhC;;;;OAIG;IACH,OAAO,CAAC,0BAA0B;IAalC;;;;OAIG;IACH,OAAO,CAAC,2BAA2B;IAUnC;;;OAGG;IACH,OAAO,CAAC,qBAAqB;IAkB7B;;;;;OAKG;IACH,OAAO,CAAC,gBAAgB;IAIxB;;;;OAIG;IACH,OAAO,CAAC,2BAA2B;CAMpC;AAkBD;;;;;;GAMG;AACH,MAAM,MAAM,OAAO,CAAC,CAAC,IAAI,CAAC,kBAAkB,EAAE,kBAAkB,KAAK,OAAO,CAAC,CAAC,CAAC,CAAC;AAwBhF,gDAAgD;AAChD,MAAM,WAAW,mBAAmB;IAClC,qCAAqC;IACrC,aAAa,EAAE,yBAAyB,CAAC;CAC1C;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,WAAW,yBAAyB;IACxC,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;;GAGG;AACH,MAAM,WAAW,yBAAyB;IACxC;;;;;OAKG;IACH,iBAAiB,IAAI,IAAI,CAAC;IAC1B;;;;;;OAMG;IACH,WAAW,IAAI,IAAI,CAAC;CACrB"}

package/dist/commonjs/core/fetchers/segment/task_prioritizer.js

@@ -1,381 +0,0 @@
-"use strict";
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
-var __values = (this && this.__values) || function(o) {
-    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
-    if (m) return m.call(o);
-    if (o && typeof o.length === "number") return {
-        next: function () {
-            if (o && i >= o.length) o = void 0;
-            return { value: o && o[i++], done: !o };
-        }
-    };
-    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-var log_1 = require("../../../log");
-var array_find_index_1 = require("../../../utils/array_find_index");
-var create_cancellable_promise_1 = require("../../../utils/create_cancellable_promise");
-var task_canceller_1 = require("../../../utils/task_canceller");
-/**
- * Utilitary class which allows to perform multiple tasks at once each with an
- * associated priority.
- *
- * This class will then schedule the given tasks in the right order based on the
- * priorities.
- *
- * @class TaskPrioritizer
- */
-var TaskPrioritizer = /** @class */ (function () {
-    /**
-     * @param {Options} prioritizerOptions
-     */
-    function TaskPrioritizer(_a) {
-        var prioritySteps = _a.prioritySteps;
-        this._minPendingPriority = null;
-        this._waitingQueue = [];
-        this._pendingTasks = [];
-        this._prioritySteps = prioritySteps;
-        if (this._prioritySteps.high >= this._prioritySteps.low) {
-            throw new Error("The max high level priority should be given a lower" +
-                "priority number than the min low priority.");
-        }
-    }
-    /**
-     * Create a priorized Promise from a base task.
-     *
-     * This task will immediately have its priority compared to all the
-     * already-running ones created from this class.
-     *
-     * Only if this number is inferior or equal to the priority of the
-     * minimum priority number of all currently-running tasks  will it be
-     * immediately started.
-     * In the opposite case, we will wait for higher-priority tasks to
-     * finish before starting it.
-     *
-     * Note that while this task is waiting for its turn, it is possible
-     * to update its property through the updatePriority method, by providing
-     * the task again and its new priority number.
-     *
-     * @param {Function} taskFn
-     * @param {number} priority
-     * @param {Object} callbacks
-     * @param {Object} cancelSignal
-     * @returns {Promise}
-     */
-    TaskPrioritizer.prototype.create = function (taskFn, priority, callbacks, cancelSignal) {
-        var _this = this;
-        var newTask;
-        return (0, create_cancellable_promise_1.default)(cancelSignal, function (resolve, reject) {
-            /** Function allowing to start the underlying Promise. */
-            var trigger = function () {
-                if (newTask.hasEnded) {
-                    return;
-                }
-                var finishTask = function () {
-                    unlinkInterrupter();
-                    _this._endTask(newTask);
-                };
-                var onResolve = function (value) {
-                    callbacks.beforeEnded();
-                    finishTask();
-                    resolve(value);
-                };
-                var onReject = function (err) {
-                    finishTask();
-                    reject(err);
-                };
-                var interrupter = new task_canceller_1.default();
-                var unlinkInterrupter = interrupter.linkToSignal(cancelSignal);
-                newTask.interrupter = interrupter;
-                interrupter.signal.register(function () {
-                    newTask.interrupter = null;
-                    if (!cancelSignal.isCancelled()) {
-                        callbacks.beforeInterrupted();
-                    }
-                });
-                _this._minPendingPriority =
-                    _this._minPendingPriority === null
-                        ? newTask.priority
-                        : Math.min(_this._minPendingPriority, newTask.priority);
-                _this._pendingTasks.push(newTask);
-                newTask
-                    .taskFn(interrupter.signal)
-                    .then(onResolve)
-                    .catch(function (err) {
-                    if (!cancelSignal.isCancelled() &&
-                        interrupter.isUsed() &&
-                        err instanceof task_canceller_1.CancellationError) {
-                        return;
-                    }
-                    onReject(err);
-                });
-            };
-            newTask = {
-                hasEnded: false,
-                priority: priority,
-                trigger: trigger,
-                taskFn: taskFn,
-                interrupter: null,
-            };
-            if (!_this._canBeStartedNow(newTask)) {
-                _this._waitingQueue.push(newTask);
-            }
-            else {
-                // We can start the task right away
-                newTask.trigger();
-                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.
-                    // This would mean re-entrancy, itself meaning that some weird
-                    // 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();
-                }
-            }
-            return function () { return _this._endTask(newTask); };
-        });
-    };
-    TaskPrioritizer.prototype._endTask = function (task) {
-        task.hasEnded = true;
-        var 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);
-            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, __spreadArray([], __read(this._pendingTasks.map(function (t) { return t.priority; })), false));
-                }
-            }
-            else {
-                this._minPendingPriority = null;
-            }
-            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);
-        if (waitingQueueIndex >= 0) {
-            // If it was still waiting for its turn
-            var waitingQueueElt = this._waitingQueue[waitingQueueIndex];
-            if (waitingQueueElt.priority === priority) {
-                return;
-            }
-            waitingQueueElt.priority = priority;
-            if (!this._canBeStartedNow(waitingQueueElt)) {
-                return;
-            }
-            this._findAndRunWaitingQueueTask(waitingQueueIndex);
-            if (this._isRunningHighPriorityTasks()) {
-                // Re-check to cancel every "cancellable" pending task
-                //
-                // Note: We start the task before interrupting cancellable tasks on
-                // purpose.
-                // Because both `_findAndRunWaitingQueueTask` and
-                // `_interruptCancellableTasks` can emit events and thus call external
-                // code, we could retrieve ourselves in a very weird state at this point
-                //
-                // By starting the task first, we ensure that this is manageable:
-                // `_getMinPendingPriority()` has already been updated to the right value at
-                // the time we reached external code, the priority of the current
-                // Task has just been updated, and `_interruptCancellableTasks`
-                // will ensure that we're basing ourselves on the last `priority` value
-                // each time.
-                // Doing it in the reverse order is an order of magnitude more difficult
-                // to write and to reason about.
-                this._interruptCancellableTasks();
-            }
-            return;
-        }
-        var pendingTasksIndex = _findTaskIndex(promise, this._pendingTasks);
-        if (pendingTasksIndex < 0) {
-            log_1.default.warn("SF", "request to update the priority of a non-existent task");
-            return;
-        }
-        var task = this._pendingTasks[pendingTasksIndex];
-        if (task.priority === priority) {
-            return;
-        }
-        var prevPriority = task.priority;
-        task.priority = priority;
-        if (this._minPendingPriority === null || priority < this._minPendingPriority) {
-            this._minPendingPriority = priority;
-        }
-        else if (this._minPendingPriority === prevPriority) {
-            // was highest priority
-            if (this._pendingTasks.length === 1) {
-                this._minPendingPriority = priority;
-            }
-            else {
-                this._minPendingPriority = Math.min.apply(Math, __spreadArray([], __read(this._pendingTasks.map(function (t) { return t.priority; })), false));
-            }
-            this._loopThroughWaitingQueue();
-        }
-        if (this._isRunningHighPriorityTasks()) {
-            // Always interrupt cancellable tasks after all other side-effects, to
-            // 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
-     * `_minPendingPriority`.
-     *
-     * 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) {
-            return acc === null || acc > elt.priority ? elt.priority : acc;
-        }, null);
-        if (minWaitingPriority === null ||
-            (this._minPendingPriority !== null && this._minPendingPriority < minWaitingPriority)) {
-            return;
-        }
-        for (var i = 0; i < this._waitingQueue.length; i++) {
-            var priorityToCheck = this._minPendingPriority === null
-                ? minWaitingPriority
-                : Math.min(this._minPendingPriority, minWaitingPriority);
-            var 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 () {
-        var e_1, _a;
-        try {
-            for (var _b = __values(this._pendingTasks), _c = _b.next(); !_c.done; _c = _b.next()) {
-                var pendingObj = _c.value;
-                if (pendingObj.priority >= this._prioritySteps.low) {
-                    this._interruptPendingTask(pendingObj);
-                    // The previous call could have a lot of potential side-effects.
-                    // It is safer to re-start the function to not miss any pending
-                    // task that needs to be cancelled.
-                    return this._interruptCancellableTasks();
-                }
-            }
-        }
-        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-        finally {
-            try {
-                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-            }
-            finally { if (e_1) throw e_1.error; }
-        }
-    };
-    /**
-     * 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) {
-        if (index >= this._waitingQueue.length || index < 0) {
-            log_1.default.warn("SF", "Tried to start a non existing task");
-            return false;
-        }
-        var 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) {
-        var _a;
-        var pendingTasksIndex = _findTaskIndex(task.taskFn, this._pendingTasks);
-        if (pendingTasksIndex < 0) {
-            log_1.default.warn("SF", "Interrupting a non-existent pending task. Aborting...");
-            return;
-        }
-        // Stop task and put it back in the waiting queue
-        this._pendingTasks.splice(pendingTasksIndex, 1);
-        this._waitingQueue.push(task);
-        if (this._pendingTasks.length === 0) {
-            this._minPendingPriority = null;
-        }
-        else if (this._minPendingPriority === task.priority) {
-            this._minPendingPriority = Math.min.apply(Math, __spreadArray([], __read(this._pendingTasks.map(function (t) { return t.priority; })), false));
-        }
-        (_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) {
-        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 () {
-        return (this._minPendingPriority !== null &&
-            this._minPendingPriority <= this._prioritySteps.high);
-    };
-    return TaskPrioritizer;
-}());
-exports.default = TaskPrioritizer;
-/**
- * Simple utils function allowing to find a given task function in the given
- * `queue`.
- *
- * Returns `-1` if `taskFn` is not found.
- * @param {Function} taskFn
- * @param {Array.<Object>} queue
- * @returns {number}
- */
-function _findTaskIndex(taskFn, queue) {
-    return (0, array_find_index_1.default)(queue, function (elt) { return elt.taskFn === taskFn; });
-}

package/dist/commonjs/core/fetchers/thumbnails/index.d.ts

@@ -1,5 +0,0 @@
-import createThumbnailFetcher from "./thumbnail_fetcher";
-import type { IThumbnailFetcher } from "./thumbnail_fetcher";
-export default createThumbnailFetcher;
-export type { IThumbnailFetcher };
-//# sourceMappingURL=index.d.ts.map

package/dist/commonjs/core/fetchers/thumbnails/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/core/fetchers/thumbnails/index.ts"],"names":[],"mappings":"AAAA,OAAO,sBAAsB,MAAM,qBAAqB,CAAC;AACzD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAE7D,eAAe,sBAAsB,CAAC;AACtC,YAAY,EAAE,iBAAiB,EAAE,CAAC"}

package/dist/commonjs/core/fetchers/thumbnails/index.js

@@ -1,4 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var thumbnail_fetcher_1 = require("./thumbnail_fetcher");
-exports.default = thumbnail_fetcher_1.default;

package/dist/commonjs/core/fetchers/thumbnails/thumbnail_fetcher.d.ts

@@ -1,79 +0,0 @@
-import type { ISegment, IThumbnailTrack } from "../../../manifest";
-import type { IPeriod } from "../../../public_types";
-import type { IThumbnailPipeline, IThumbnailResponse } from "../../../transports";
-import type { CancellationSignal } from "../../../utils/task_canceller";
-import type CdnPrioritizer from "../cdn_prioritizer";
-/**
- * Create an `IThumbnailFetcher` object which will allow to easily fetch and parse
- * segments.
- * An `IThumbnailFetcher` also implements a retry mechanism, based on the given
- * `requestOptions` argument, which may retry a segment request when it fails.
- *
- * @param {Object} pipeline
- * @param {Object|null} cdnPrioritizer
- * @returns {Function}
- */
-export default function createThumbnailFetcher(
-/** The transport-specific logic allowing to load thumbnails. */
-pipeline: IThumbnailPipeline, 
-/**
- * Abstraction allowing to synchronize, update and keep track of the
- * priorization of the CDN to use to load any given segment, in cases where
- * multiple ones are available.
- *
- * Can be set to `null` in which case a minimal priorization logic will be used
- * instead.
- */
-cdnPrioritizer: CdnPrioritizer | null): IThumbnailFetcher;
-/**
- * Defines the `IThumbnailFetcher` 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 type IThumbnailFetcher = (
-/** Context on the thumbnail you want to load */
-thumbnailContext: {
-    /** Thumbnail "segment". */
-    segment: ISegment;
-    /** Metadata on the linked thumbnails track. */
-    track: IThumbnailTrack;
-    /** Metadata on the `Period` this thumbnail track is a part of. */
-    period: IPeriod;
-}, 
-/** CancellationSignal allowing to cancel the request. */
-cancellationSignal: CancellationSignal) => Promise<IThumbnailResponse>;
-/** requestOptions allowing to configure an `IThumbnailFetcher`'s behavior. */
-export interface IThumbnailFetcherOptions {
-    /**
-     * Initial delay to wait if a request fails before making a new request, in
-     * milliseconds.
-     */
-    baseDelay: number;
-    /**
-     * Maximum delay to wait if a request fails before making a new request, in
-     * milliseconds.
-     */
-    maxDelay: number;
-    /**
-     * Maximum number of retries to perform on "regular" errors (e.g. due to HTTP
-     * status, integrity errors, timeouts...).
-     */
-    maxRetry: number;
-    /**
-     * Timeout after which request are aborted and, depending on other requestOptions,
-     * retried.
-     * To set to `-1` for no timeout.
-     */
-    requestTimeout: number;
-    /**
-     * Connection timeout, in milliseconds, after which the request is canceled
-     * if the responses headers has not being received.
-     * Do not set or set to "undefined" to disable it.
-     */
-    connectionTimeout: number | undefined;
-}
-//# sourceMappingURL=thumbnail_fetcher.d.ts.map

package/dist/commonjs/core/fetchers/thumbnails/thumbnail_fetcher.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"thumbnail_fetcher.d.ts","sourceRoot":"","sources":["../../../../../src/core/fetchers/thumbnails/thumbnail_fetcher.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,QAAQ,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAEnE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AACrD,OAAO,KAAK,EAGV,kBAAkB,EAClB,kBAAkB,EACnB,MAAM,qBAAqB,CAAC;AAG7B,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,+BAA+B,CAAC;AAExE,OAAO,KAAK,cAAc,MAAM,oBAAoB,CAAC;AAIrD;;;;;;;;;GASG;AACH,MAAM,CAAC,OAAO,UAAU,sBAAsB;AAC5C,gEAAgE;AAChE,QAAQ,EAAE,kBAAkB;AAC5B;;;;;;;GAOG;AACH,cAAc,EAAE,cAAc,GAAG,IAAI,GAEpC,iBAAiB,CAsNnB;AAED;;;;;;;;GAQG;AACH,MAAM,MAAM,iBAAiB,GAAG;AAC9B,gDAAgD;AAChD,gBAAgB,EAAE;IAChB,2BAA2B;IAC3B,OAAO,EAAE,QAAQ,CAAC;IAClB,+CAA+C;IAC/C,KAAK,EAAE,eAAe,CAAC;IACvB,kEAAkE;IAClE,MAAM,EAAE,OAAO,CAAC;CACjB;AACD,yDAAyD;AACzD,kBAAkB,EAAE,kBAAkB,KACnC,OAAO,CAAC,kBAAkB,CAAC,CAAC;AAEjC,8EAA8E;AAC9E,MAAM,WAAW,wBAAwB;IACvC;;;OAGG;IACH,SAAS,EAAE,MAAM,CAAC;IAClB;;;OAGG;IACH,QAAQ,EAAE,MAAM,CAAC;IACjB;;;OAGG;IACH,QAAQ,EAAE,MAAM,CAAC;IACjB;;;;OAIG;IACH,cAAc,EAAE,MAAM,CAAC;IACvB;;;;OAIG;IACH,iBAAiB,EAAE,MAAM,GAAG,SAAS,CAAC;CACvC"}