rx-player 4.0.0-beta.2 → 4.0.0-beta.3

package/dist/_esm5.processed/compat/should_wait_for_data_before_loaded.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 { isSafariMobile } from "./browser_detection";
+Object.defineProperty(exports, "__esModule", { value: true });
+const browser_detection_1 = require("./browser_detection");
 /**
  * On some browsers, the ready state might never go above `1` when autoplay is
  * blocked. On these cases, for now, we just advertise the content as "loaded".
@@ -22,9 +24,10 @@ import { isSafariMobile } from "./browser_detection";
  * @param {Boolean} isDirectfile
  * @returns {Boolean}
  */
-export default function shouldWaitForDataBeforeLoaded(isDirectfile, mustPlayInline) {
-    if (isDirectfile && isSafariMobile) {
+function shouldWaitForDataBeforeLoaded(isDirectfile, mustPlayInline) {
+    if (isDirectfile && browser_detection_1.isSafariMobile) {
         return mustPlayInline;
     }
     return true;
 }
+exports.default = shouldWaitForDataBeforeLoaded;

package/dist/_esm5.processed/compat/should_wait_for_have_enough_data.d.ts

@@ -0,0 +1,13 @@
+/**
+ * An `HTMLMediaElement`'s readyState allows the browser to communicate whether
+ * it can play a content reliably.
+ * Usually, we may consider that a `HAVE_FUTURE_DATA` (readyState `3`) or even
+ * a `HAVE_CURRENT_DATA` (readyState `2`) is enough to begin playing the content
+ * and consider it as loaded.
+ *
+ * However some devices wrongly anounce those readyStates before being actually
+ * able to decode the content. For those devices we wait for the
+ * `HAVE_ENOUGH_DATA` readyState before considering the content as loaded.
+ * @returns {boolean}
+ */
+export default function shouldWaitForHaveEnoughData(): boolean;

package/dist/_esm5.processed/compat/should_wait_for_have_enough_data.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const browser_detection_1 = require("./browser_detection");
+/**
+ * An `HTMLMediaElement`'s readyState allows the browser to communicate whether
+ * it can play a content reliably.
+ * Usually, we may consider that a `HAVE_FUTURE_DATA` (readyState `3`) or even
+ * a `HAVE_CURRENT_DATA` (readyState `2`) is enough to begin playing the content
+ * and consider it as loaded.
+ *
+ * However some devices wrongly anounce those readyStates before being actually
+ * able to decode the content. For those devices we wait for the
+ * `HAVE_ENOUGH_DATA` readyState before considering the content as loaded.
+ * @returns {boolean}
+ */
+function shouldWaitForHaveEnoughData() {
+    return browser_detection_1.isPlayStation5;
+}
+exports.default = shouldWaitForHaveEnoughData;

package/dist/_esm5.processed/config.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,20 +14,20 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import DEFAULT_CONFIG from "./default_config";
-import deepMerge from "./utils/deep_merge";
-var ConfigHandler = /** @class */ (function () {
-    function ConfigHandler() {
-        this._config = DEFAULT_CONFIG;
+Object.defineProperty(exports, "__esModule", { value: true });
+const default_config_1 = require("./default_config");
+const deep_merge_1 = require("./utils/deep_merge");
+class ConfigHandler {
+    constructor() {
+        this._config = default_config_1.default;
     }
-    ConfigHandler.prototype.update = function (config) {
-        var newConfig = deepMerge(this._config, config);
+    update(config) {
+        const newConfig = (0, deep_merge_1.default)(this._config, config);
         this._config = newConfig;
-    };
-    ConfigHandler.prototype.getCurrent = function () {
+    }
+    getCurrent() {
         return this._config;
-    };
-    return ConfigHandler;
-}());
-var configHandler = new ConfigHandler();
-export default configHandler;
+    }
+}
+const configHandler = new ConfigHandler();
+exports.default = configHandler;

package/dist/_esm5.processed/core/adaptive/adaptive_representation_selector.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,27 +14,27 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import config from "../../config";
-import log from "../../log";
-import noop from "../../utils/noop";
-import { getLeftSizeOfRange } from "../../utils/ranges";
-import createSharedReference from "../../utils/reference";
-import takeFirstSet from "../../utils/take_first_set";
-import TaskCanceller from "../../utils/task_canceller";
-import BufferBasedChooser from "./buffer_based_chooser";
-import GuessBasedChooser from "./guess_based_chooser";
-import NetworkAnalyzer from "./network_analyzer";
-import BandwidthEstimator from "./utils/bandwidth_estimator";
-import filterByBitrate from "./utils/filter_by_bitrate";
-import filterByResolution from "./utils/filter_by_resolution";
-import LastEstimateStorage from "./utils/last_estimate_storage";
-import PendingRequestsStore from "./utils/pending_requests_store";
-import RepresentationScoreCalculator from "./utils/representation_score_calculator";
-import selectOptimalRepresentation from "./utils/select_optimal_representation";
+Object.defineProperty(exports, "__esModule", { value: true });
+const config_1 = require("../../config");
+const log_1 = require("../../log");
+const noop_1 = require("../../utils/noop");
+const ranges_1 = require("../../utils/ranges");
+const reference_1 = require("../../utils/reference");
+const task_canceller_1 = require("../../utils/task_canceller");
+const buffer_based_chooser_1 = require("./buffer_based_chooser");
+const guess_based_chooser_1 = require("./guess_based_chooser");
+const network_analyzer_1 = require("./network_analyzer");
+const bandwidth_estimator_1 = require("./utils/bandwidth_estimator");
+const filter_by_bitrate_1 = require("./utils/filter_by_bitrate");
+const filter_by_resolution_1 = require("./utils/filter_by_resolution");
+const last_estimate_storage_1 = require("./utils/last_estimate_storage");
+const pending_requests_store_1 = require("./utils/pending_requests_store");
+const representation_score_calculator_1 = require("./utils/representation_score_calculator");
+const select_optimal_representation_1 = require("./utils/select_optimal_representation");
 // Create default shared references
-var limitWidthDefaultRef = createSharedReference(undefined);
+const limitWidthDefaultRef = new reference_1.default(undefined);
 limitWidthDefaultRef.finish();
-var throttleBitrateDefaultRef = createSharedReference(Infinity);
+const throttleBitrateDefaultRef = new reference_1.default(Infinity);
 throttleBitrateDefaultRef.finish();
 /**
  * Select the most adapted Representation according to the network and buffer
@@ -43,13 +44,13 @@ throttleBitrateDefaultRef.finish();
  * @returns {Object} - Interface allowing to select a Representation.
  * @see IRepresentationEstimator
  */
-export default function createAdaptiveRepresentationSelector(options) {
+function createAdaptiveRepresentationSelector(options) {
     /**
      * Allows to estimate the current network bandwidth.
      * One per active media type.
      */
-    var bandwidthEstimators = {};
-    var initialBitrates = options.initialBitrates, throttlers = options.throttlers, lowLatencyMode = options.lowLatencyMode;
+    const bandwidthEstimators = {};
+    const { initialBitrates, throttlers, lowLatencyMode } = options;
     /**
      * Returns Object emitting Representation estimates as well as callbacks
      * allowing to helping it produce them.
@@ -63,14 +64,22 @@ export default function createAdaptiveRepresentationSelector(options) {
      * @returns {Array.<Object>}
      */
     return function getEstimates(context, currentRepresentation, representations, playbackObserver, stopAllEstimates) {
-        var type = context.adaptation.type;
-        var bandwidthEstimator = _getBandwidthEstimator(type);
-        var initialBitrate = takeFirstSet(initialBitrates[type], 0);
-        var filters = {
-            limitResolution: takeFirstSet(throttlers.limitResolution[type], limitWidthDefaultRef),
-            throttleBitrate: takeFirstSet(throttlers.throttleBitrate[type], throttleBitrateDefaultRef),
+        var _a, _b, _c;
+        const { type } = context.adaptation;
+        const bandwidthEstimator = _getBandwidthEstimator(type);
+        const initialBitrate = (_a = initialBitrates[type]) !== null && _a !== void 0 ? _a : 0;
+        const filters = {
+            limitResolution: (_b = throttlers.limitResolution[type]) !== null && _b !== void 0 ? _b : limitWidthDefaultRef,
+            throttleBitrate: (_c = throttlers.throttleBitrate[type]) !== null && _c !== void 0 ? _c : throttleBitrateDefaultRef,
         };
-        return getEstimateReference({ bandwidthEstimator: bandwidthEstimator, context: context, currentRepresentation: currentRepresentation, filters: filters, initialBitrate: initialBitrate, playbackObserver: playbackObserver, representations: representations, lowLatencyMode: lowLatencyMode }, stopAllEstimates);
+        return getEstimateReference({ bandwidthEstimator,
+            context,
+            currentRepresentation,
+            filters,
+            initialBitrate,
+            playbackObserver,
+            representations,
+            lowLatencyMode }, stopAllEstimates);
     };
     /**
      * Returns interface allowing to estimate network throughtput for a given type.
@@ -78,16 +87,17 @@ export default function createAdaptiveRepresentationSelector(options) {
      * @returns {Object}
      */
     function _getBandwidthEstimator(bufferType) {
-        var originalBandwidthEstimator = bandwidthEstimators[bufferType];
+        const originalBandwidthEstimator = bandwidthEstimators[bufferType];
         if (originalBandwidthEstimator == null) {
-            log.debug("ABR: Creating new BandwidthEstimator for ", bufferType);
-            var bandwidthEstimator = new BandwidthEstimator();
+            log_1.default.debug("ABR: Creating new BandwidthEstimator for ", bufferType);
+            const bandwidthEstimator = new bandwidth_estimator_1.default();
             bandwidthEstimators[bufferType] = bandwidthEstimator;
             return bandwidthEstimator;
         }
         return originalBandwidthEstimator;
     }
 }
+exports.default = createAdaptiveRepresentationSelector;
 /**
  * Estimate regularly the current network bandwidth and the best Representation
  * that can be played according to the current network and playback conditions.
@@ -107,66 +117,80 @@ export default function createAdaptiveRepresentationSelector(options) {
  * @param {Object} stopAllEstimates
  * @returns {Array.<Object>}
  */
-function getEstimateReference(_a, stopAllEstimates) {
-    var bandwidthEstimator = _a.bandwidthEstimator, context = _a.context, currentRepresentation = _a.currentRepresentation, filters = _a.filters, initialBitrate = _a.initialBitrate, lowLatencyMode = _a.lowLatencyMode, playbackObserver = _a.playbackObserver, representationsRef = _a.representations;
-    var scoreCalculator = new RepresentationScoreCalculator();
-    var networkAnalyzer = new NetworkAnalyzer(initialBitrate !== null && initialBitrate !== void 0 ? initialBitrate : 0, lowLatencyMode);
-    var requestsStore = new PendingRequestsStore();
-    var onAddedSegment = noop;
-    var callbacks = {
+function getEstimateReference({ bandwidthEstimator, context, currentRepresentation, filters, initialBitrate, lowLatencyMode, playbackObserver, representations: representationsRef }, stopAllEstimates) {
+    const scoreCalculator = new representation_score_calculator_1.default();
+    const networkAnalyzer = new network_analyzer_1.default(initialBitrate !== null && initialBitrate !== void 0 ? initialBitrate : 0, lowLatencyMode);
+    const requestsStore = new pending_requests_store_1.default();
+    /**
+     * Callback called each time a new segment is pushed, with the information on the
+     * new pushed segment.
+     */
+    let onAddedSegment = noop_1.default;
+    const callbacks = {
         metrics: onMetric,
         requestBegin: onRequestBegin,
         requestProgress: onRequestProgress,
         requestEnd: onRequestEnd,
-        addedSegment: function (val) { onAddedSegment(val); },
+        addedSegment(val) { onAddedSegment(val); },
     };
     /**
      * `TaskCanceller` allowing to stop producing estimate.
      * This TaskCanceller is used both for restarting estimates with a new
      * configuration and to cancel them altogether.
      */
-    var currentEstimatesCanceller = new TaskCanceller();
+    let currentEstimatesCanceller = new task_canceller_1.default();
     currentEstimatesCanceller.linkToSignal(stopAllEstimates);
-    // Create `ISharedReference` on which estimates will be emitted.
-    var estimateRef = createEstimateReference(representationsRef.getValue(), currentEstimatesCanceller.signal);
+    // Create `SharedReference` on which estimates will be emitted.
+    const estimateRef = createEstimateReference(representationsRef.getValue(), currentEstimatesCanceller.signal);
     representationsRef.onUpdate(restartEstimatesProductionFromCurrentConditions, { clearSignal: stopAllEstimates });
-    return { estimates: estimateRef, callbacks: callbacks };
-    function createEstimateReference(representations, innerCancellationSignal) {
-        if (representations.length === 1) {
+    return { estimates: estimateRef, callbacks };
+    /**
+     * Emit the ABR estimates on various events through the returned
+     * `SharedReference`.
+     * @param {Array.<Object>} unsortedRepresentations - All `Representation` that
+     * the ABR logic can choose from.
+     * @param {Object} innerCancellationSignal - When this `CancellationSignal`
+     * emits, all events registered to to emit new estimates will be unregistered.
+     * Note that the returned reference may still be used to produce new estimates
+     * in the future if you want to even after this signal emits.
+     * @returns {Object} - `SharedReference` through which ABR estimates will be
+     * produced.
+     */
+    function createEstimateReference(unsortedRepresentations, innerCancellationSignal) {
+        if (unsortedRepresentations.length <= 1) {
             // There's only a single Representation. Just choose it.
-            return createSharedReference({ bitrate: undefined,
-                representation: representations[0],
+            return new reference_1.default({
+                bitrate: undefined,
+                representation: unsortedRepresentations[0],
                 urgent: true,
-                knownStableBitrate: undefined });
+                knownStableBitrate: undefined,
+            });
         }
         /** If true, Representation estimates based on the buffer health might be used. */
-        var allowBufferBasedEstimates = false;
-        /**
-         * Current optimal Representation's bandwidth choosen by a buffer-based
-         * adaptive algorithm.
-         */
-        var currentBufferBasedEstimate;
-        var bitrates = representations.map(function (r) { return r.bitrate; });
+        let allowBufferBasedEstimates = false;
+        /** Ensure `Representation` objects are sorted by bitrates and only rely on this. */
+        const sortedRepresentations = unsortedRepresentations
+            .sort((ra, rb) => ra.bitrate - rb.bitrate);
         /**
          * Module calculating the optimal Representation based on the current
          * buffer's health (i.e. whether enough data is buffered, history of
          * buffer size etc.).
          */
-        var bufferBasedChooser = new BufferBasedChooser(bitrates);
+        const bufferBasedChooser = new buffer_based_chooser_1.default(sortedRepresentations.map(r => r.bitrate));
         /** Store the previous estimate made here. */
-        var prevEstimate = new LastEstimateStorage();
+        const prevEstimate = new last_estimate_storage_1.default();
         /**
          * Module calculating the optimal Representation by "guessing it" with a
          * step-by-step algorithm.
          * Only used in very specific scenarios.
          */
-        var guessBasedChooser = new GuessBasedChooser(scoreCalculator, prevEstimate);
+        const guessBasedChooser = new guess_based_chooser_1.default(scoreCalculator, prevEstimate);
         // get initial observation for initial estimate
-        var lastPlaybackObservation = playbackObserver.getReference().getValue();
+        let lastPlaybackObservation = playbackObserver.getReference().getValue();
         /** Reference through which estimates are emitted. */
-        var innerEstimateRef = createSharedReference(getCurrentEstimate());
+        const innerEstimateRef = new reference_1.default(getCurrentEstimate());
         // Listen to playback observations
-        playbackObserver.listen(function (obs) {
+        playbackObserver.listen((obs) => {
             lastPlaybackObservation = obs;
             updateEstimate();
         }, { includeLastObservation: false, clearSignal: innerCancellationSignal });
@@ -174,18 +198,18 @@ function getEstimateReference(_a, stopAllEstimates) {
             if (lastPlaybackObservation === null) {
                 return;
             }
-            var position = lastPlaybackObservation.position, speed = lastPlaybackObservation.speed;
-            var timeRanges = val.buffered;
-            var bufferGap = getLeftSizeOfRange(timeRanges, position.last);
-            var representation = val.content.representation;
-            var currentScore = scoreCalculator.getEstimate(representation);
-            var currentBitrate = representation.bitrate;
-            var observation = { bufferGap: bufferGap, currentBitrate: currentBitrate, currentScore: currentScore, speed: speed };
-            currentBufferBasedEstimate = bufferBasedChooser.getEstimate(observation);
+            const { position, speed } = lastPlaybackObservation;
+            const timeRanges = val.buffered;
+            const bufferGap = (0, ranges_1.getLeftSizeOfBufferedTimeRange)(timeRanges, position.last);
+            const { representation } = val.content;
+            const currentScore = scoreCalculator.getEstimate(representation);
+            const currentBitrate = representation.bitrate;
+            const observation = { bufferGap, currentBitrate, currentScore, speed };
+            bufferBasedChooser.onAddedSegment(observation);
             updateEstimate();
         };
-        innerCancellationSignal.register(function () {
-            onAddedSegment = noop;
+        innerCancellationSignal.register(() => {
+            onAddedSegment = noop_1.default;
         });
         filters.throttleBitrate.onUpdate(updateEstimate, { clearSignal: innerCancellationSignal });
         filters.limitResolution.onUpdate(updateEstimate, { clearSignal: innerCancellationSignal });
@@ -195,21 +219,21 @@ function getEstimateReference(_a, stopAllEstimates) {
         }
         /** Returns the actual estimate based on all methods and algorithm available. */
         function getCurrentEstimate() {
-            var bufferGap = lastPlaybackObservation.bufferGap, position = lastPlaybackObservation.position, maximumPosition = lastPlaybackObservation.maximumPosition;
-            var resolutionLimit = filters.limitResolution.getValue();
-            var bitrateThrottle = filters.throttleBitrate.getValue();
-            var currentRepresentationVal = currentRepresentation.getValue();
-            var filteredReps = getFilteredRepresentations(representations, resolutionLimit, bitrateThrottle);
-            var requests = requestsStore.getRequests();
-            var _a = networkAnalyzer
-                .getBandwidthEstimate(lastPlaybackObservation, bandwidthEstimator, currentRepresentationVal, requests, prevEstimate.bandwidth), bandwidthEstimate = _a.bandwidthEstimate, bitrateChosen = _a.bitrateChosen;
-            var stableRepresentation = scoreCalculator.getLastStableRepresentation();
-            var knownStableBitrate = stableRepresentation === null ?
+            const { bufferGap, position, maximumPosition } = lastPlaybackObservation;
+            const resolutionLimit = filters.limitResolution.getValue();
+            const bitrateThrottle = filters.throttleBitrate.getValue();
+            const currentRepresentationVal = currentRepresentation.getValue();
+            const filteredReps = getFilteredRepresentations(sortedRepresentations, resolutionLimit, bitrateThrottle);
+            const requests = requestsStore.getRequests();
+            const { bandwidthEstimate, bitrateChosen } = networkAnalyzer
+                .getBandwidthEstimate(lastPlaybackObservation, bandwidthEstimator, currentRepresentationVal, requests, prevEstimate.bandwidth);
+            const stableRepresentation = scoreCalculator.getLastStableRepresentation();
+            const knownStableBitrate = stableRepresentation === null ?
                 undefined :
                 stableRepresentation.bitrate / (lastPlaybackObservation.speed > 0 ?
                     lastPlaybackObservation.speed :
                     1);
-            var _b = config.getCurrent(), ABR_ENTER_BUFFER_BASED_ALGO = _b.ABR_ENTER_BUFFER_BASED_ALGO, ABR_EXIT_BUFFER_BASED_ALGO = _b.ABR_EXIT_BUFFER_BASED_ALGO;
+            const { ABR_ENTER_BUFFER_BASED_ALGO, ABR_EXIT_BUFFER_BASED_ALGO } = config_1.default.getCurrent();
             if (allowBufferBasedEstimates && bufferGap <= ABR_EXIT_BUFFER_BASED_ALGO) {
                 allowBufferBasedEstimates = false;
             }
@@ -224,8 +248,13 @@ function getEstimateReference(_a, stopAllEstimates) {
              * This is a safe enough choice but might be lower than what the user
              * could actually profit from.
              */
-            var chosenRepFromBandwidth = selectOptimalRepresentation(filteredReps, bitrateChosen);
-            var currentBestBitrate = chosenRepFromBandwidth.bitrate;
+            const chosenRepFromBandwidth = (0, select_optimal_representation_1.default)(filteredReps, bitrateChosen);
+            /**
+             * Current optimal Representation's bandwidth choosen by a buffer-based
+             * adaptive algorithm.
+             */
+            const currentBufferBasedEstimate = bufferBasedChooser.getLastEstimate();
+            let currentBestBitrate = chosenRepFromBandwidth.bitrate;
             /**
              * Representation chosen when considering the current buffer size.
              * If defined, takes precedence over `chosenRepFromBandwidth`.
@@ -236,11 +265,11 @@ function getEstimateReference(_a, stopAllEstimates) {
              * `null` if this buffer size mode is not enabled or if we don't have a
              * choice from it yet.
              */
-            var chosenRepFromBufferSize = null;
+            let chosenRepFromBufferSize = null;
             if (allowBufferBasedEstimates &&
                 currentBufferBasedEstimate !== undefined &&
                 currentBufferBasedEstimate > currentBestBitrate) {
-                chosenRepFromBufferSize = selectOptimalRepresentation(filteredReps, currentBufferBasedEstimate);
+                chosenRepFromBufferSize = (0, select_optimal_representation_1.default)(filteredReps, currentBufferBasedEstimate);
                 currentBestBitrate = chosenRepFromBufferSize.bitrate;
             }
             /**
@@ -258,36 +287,39 @@ function getEstimateReference(_a, stopAllEstimates) {
              *
              * `null` if not enabled or if there's currently no guess.
              */
-            var chosenRepFromGuessMode = null;
+            let chosenRepFromGuessMode = null;
             if (lowLatencyMode &&
                 currentRepresentationVal !== null &&
                 context.manifest.isDynamic &&
                 maximumPosition - position.last < 40) {
                 chosenRepFromGuessMode = guessBasedChooser
-                    .getGuess(representations, lastPlaybackObservation, currentRepresentationVal, currentBestBitrate, requests);
+                    .getGuess(sortedRepresentations, lastPlaybackObservation, currentRepresentationVal, currentBestBitrate, requests);
             }
             if (chosenRepFromGuessMode !== null &&
                 chosenRepFromGuessMode.bitrate > currentBestBitrate) {
-                log.debug("ABR: Choosing representation with guess-based estimation.", chosenRepFromGuessMode.bitrate, chosenRepFromGuessMode.id);
+                log_1.default.debug("ABR: Choosing representation with guess-based estimation.", chosenRepFromGuessMode.bitrate, chosenRepFromGuessMode.id);
                 prevEstimate.update(chosenRepFromGuessMode, bandwidthEstimate, 2 /* ABRAlgorithmType.GuessBased */);
                 return { bitrate: bandwidthEstimate,
                     representation: chosenRepFromGuessMode,
                     urgent: currentRepresentationVal === null ||
-                        chosenRepFromGuessMode.bitrate < currentRepresentationVal.bitrate, knownStableBitrate: knownStableBitrate };
+                        chosenRepFromGuessMode.bitrate < currentRepresentationVal.bitrate,
+                    knownStableBitrate };
             }
             else if (chosenRepFromBufferSize !== null) {
-                log.debug("ABR: Choosing representation with buffer-based estimation.", chosenRepFromBufferSize.bitrate, chosenRepFromBufferSize.id);
+                log_1.default.debug("ABR: Choosing representation with buffer-based estimation.", chosenRepFromBufferSize.bitrate, chosenRepFromBufferSize.id);
                 prevEstimate.update(chosenRepFromBufferSize, bandwidthEstimate, 0 /* ABRAlgorithmType.BufferBased */);
                 return { bitrate: bandwidthEstimate,
                     representation: chosenRepFromBufferSize,
-                    urgent: networkAnalyzer.isUrgent(chosenRepFromBufferSize.bitrate, currentRepresentationVal, requests, lastPlaybackObservation), knownStableBitrate: knownStableBitrate };
+                    urgent: networkAnalyzer.isUrgent(chosenRepFromBufferSize.bitrate, currentRepresentationVal, requests, lastPlaybackObservation),
+                    knownStableBitrate };
             }
             else {
-                log.debug("ABR: Choosing representation with bandwidth estimation.", chosenRepFromBandwidth.bitrate, chosenRepFromBandwidth.id);
+                log_1.default.debug("ABR: Choosing representation with bandwidth estimation.", chosenRepFromBandwidth.bitrate, chosenRepFromBandwidth.id);
                 prevEstimate.update(chosenRepFromBandwidth, bandwidthEstimate, 1 /* ABRAlgorithmType.BandwidthBased */);
                 return { bitrate: bandwidthEstimate,
                     representation: chosenRepFromBandwidth,
-                    urgent: networkAnalyzer.isUrgent(chosenRepFromBandwidth.bitrate, currentRepresentationVal, requests, lastPlaybackObservation), knownStableBitrate: knownStableBitrate };
+                    urgent: networkAnalyzer.isUrgent(chosenRepFromBandwidth.bitrate, currentRepresentationVal, requests, lastPlaybackObservation),
+                    knownStableBitrate };
             }
         }
     }
@@ -296,11 +328,11 @@ function getEstimateReference(_a, stopAllEstimates) {
      * conditions (such as a new list of Representations).
      */
     function restartEstimatesProductionFromCurrentConditions() {
-        var representations = representationsRef.getValue();
+        const representations = representationsRef.getValue();
         currentEstimatesCanceller.cancel();
-        currentEstimatesCanceller = new TaskCanceller();
+        currentEstimatesCanceller = new task_canceller_1.default();
         currentEstimatesCanceller.linkToSignal(stopAllEstimates);
-        var newRef = createEstimateReference(representations, currentEstimatesCanceller.signal);
+        const newRef = createEstimateReference(representations, currentEstimatesCanceller.signal);
         newRef.onUpdate(function onNewEstimate(newEstimate) {
             estimateRef.setValue(newEstimate);
         }, { clearSignal: currentEstimatesCanceller.signal,
@@ -311,17 +343,17 @@ function getEstimateReference(_a, stopAllEstimates) {
      * @param {Object} value
      */
     function onMetric(value) {
-        var requestDuration = value.requestDuration, segmentDuration = value.segmentDuration, size = value.size, content = value.content;
+        const { requestDuration, segmentDuration, size, content } = value;
         // calculate bandwidth
         bandwidthEstimator.addSample(requestDuration, size);
         if (!content.segment.isInit) {
             // calculate "maintainability score"
-            var segment = content.segment, representation = content.representation;
+            const { segment, representation } = content;
             if (segmentDuration === undefined && !segment.complete) {
                 // We cannot know the real duration of the segment
                 return;
             }
-            var segDur = segmentDuration !== null && segmentDuration !== void 0 ? segmentDuration : segment.duration;
+            const segDur = segmentDuration !== null && segmentDuration !== void 0 ? segmentDuration : segment.duration;
             scoreCalculator.addSample(representation, requestDuration / 1000, segDur);
         }
     }
@@ -346,12 +378,12 @@ function getEstimateReference(_a, stopAllEstimates) {
  * @returns {Array.<Representation>}
  */
 function getFilteredRepresentations(representations, resolutionLimit, bitrateThrottle) {
-    var filteredReps = representations;
+    let filteredReps = representations;
     if (bitrateThrottle !== undefined && bitrateThrottle < Infinity) {
-        filteredReps = filterByBitrate(filteredReps, bitrateThrottle);
+        filteredReps = (0, filter_by_bitrate_1.default)(filteredReps, bitrateThrottle);
     }
     if (resolutionLimit !== undefined) {
-        filteredReps = filterByResolution(filteredReps, resolutionLimit);
+        filteredReps = (0, filter_by_resolution_1.default)(filteredReps, resolutionLimit);
     }
     return filteredReps;
 }

package/dist/_esm5.processed/core/adaptive/buffer_based_chooser.d.ts

@@ -33,8 +33,15 @@ export default class BufferBasedChooser {
     private _levelsMap;
     private _bitrates;
     /**
-     * Laast timestamp, in terms of `performance.now`, at which the current
-     * quality was seen as too high by this algorithm.
+     * Current last best Representation's bitrate estimate made by the
+     * `BufferBasedChooser` or `undefined` if it has no such guess for now.
+     *
+     * Might be updated each time `onAddedSegment` is called.
+     */
+    private _currentEstimate;
+    /**
+     * Last monotonically-raising timestamp (as defined by the RxPlayer), at which
+     * the current quality was seen as too high by this algorithm.
      * Begins at `undefined`.
      */
     private _lastUnsuitableQualityTimestamp;
@@ -54,7 +61,16 @@ export default class BufferBasedChooser {
      * @param {Object} playbackObservation
      * @returns {number|undefined}
      */
-    getEstimate(playbackObservation: IBufferBasedChooserPlaybackObservation): number | undefined;
+    onAddedSegment(playbackObservation: IBufferBasedChooserPlaybackObservation): void;
+    /**
+     * Returns the last best Representation's bitrate estimate made by the
+     * `BufferBasedChooser` or `undefined` if it has no such guess for now.
+     *
+     * Might be updated after `onAddedSegment` is called.
+     *
+     * @returns {number|undefined}
+     */
+    getLastEstimate(): number | undefined;
 }
 /** Playback observation needed by the `BufferBasedChooser`. */
 export interface IBufferBasedChooserPlaybackObservation {