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

package/dist/_esm5.processed/core/stream/adaptation/adaptation_stream.js

@@ -1,51 +1,17 @@
-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 assertUnreachable from "../../../utils/assert_unreachable";
-import cancellableSleep from "../../../utils/cancellable_sleep";
-import noop from "../../../utils/noop";
-import objectAssign from "../../../utils/object_assign";
-import { createMappedReference, createSharedReference, } from "../../../utils/reference";
-import TaskCanceller from "../../../utils/task_canceller";
-import RepresentationStream from "../representation";
-import createReloadRequest from "../utils/create_reload_request";
-import getRepresentationsSwitchingStrategy from "./get_representations_switch_strategy";
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const next_tick_1 = require("next-tick");
+const config_1 = require("../../../config");
+const errors_1 = require("../../../errors");
+const log_1 = require("../../../log");
+const assert_unreachable_1 = require("../../../utils/assert_unreachable");
+const cancellable_sleep_1 = require("../../../utils/cancellable_sleep");
+const noop_1 = require("../../../utils/noop");
+const object_assign_1 = require("../../../utils/object_assign");
+const reference_1 = require("../../../utils/reference");
+const task_canceller_1 = require("../../../utils/task_canceller");
+const representation_1 = require("../representation");
+const get_representations_switch_strategy_1 = require("./get_representations_switch_strategy");
 /**
  * Create new `AdaptationStream` whose task will be to download the media data
  * for a given Adaptation (i.e. "track").
@@ -76,11 +42,10 @@ import getRepresentationsSwitchingStrategy from "./get_representations_switch_st
  * triggered, to immediately stop all operations the `AdaptationStream` is
  * doing.
  */
-export default function AdaptationStream(_a, callbacks, parentCancelSignal) {
-    var playbackObserver = _a.playbackObserver, content = _a.content, options = _a.options, representationEstimator = _a.representationEstimator, segmentBuffer = _a.segmentBuffer, segmentFetcherCreator = _a.segmentFetcherCreator, wantedBufferAhead = _a.wantedBufferAhead, maxVideoBufferSize = _a.maxVideoBufferSize;
-    var manifest = content.manifest, period = content.period, adaptation = content.adaptation;
+function AdaptationStream({ playbackObserver, content, options, representationEstimator, segmentBuffer, segmentFetcherCreator, wantedBufferAhead, maxVideoBufferSize }, callbacks, parentCancelSignal) {
+    const { manifest, period, adaptation } = content;
     /** Allows to cancel everything the `AdaptationStream` is doing. */
-    var adapStreamCanceller = new TaskCanceller();
+    const adapStreamCanceller = new task_canceller_1.default();
     adapStreamCanceller.linkToSignal(parentCancelSignal);
     /**
      * The buffer goal ratio base itself on the value given by `wantedBufferAhead`
@@ -90,20 +55,20 @@ export default function AdaptationStream(_a, callbacks, parentCancelSignal) {
      * buffering and tells us that we should try to bufferize less data :
      * https://developers.google.com/web/updates/2017/10/quotaexceedederror
      */
-    var bufferGoalRatioMap = new Map();
+    const bufferGoalRatioMap = new Map();
     /**
      * Emit the currently chosen `Representation`.
      * `null` if no Representation is chosen for now.
      */
-    var currentRepresentation = createSharedReference(null, adapStreamCanceller.signal);
+    const currentRepresentation = new reference_1.default(null, adapStreamCanceller.signal);
     /** Stores the last emitted bitrate. */
-    var previouslyEmittedBitrate;
+    let previouslyEmittedBitrate;
     /** Emit the list of Representation for the adaptive logic. */
-    var representationsList = createSharedReference(content.representations.getValue().representations, adapStreamCanceller.signal);
+    const representationsList = new reference_1.default(content.representations.getValue().representations, adapStreamCanceller.signal);
     // Start-up Adaptive logic
-    var _b = representationEstimator({ manifest: manifest, period: period, adaptation: adaptation }, currentRepresentation, representationsList, playbackObserver, adapStreamCanceller.signal), estimateRef = _b.estimates, abrCallbacks = _b.callbacks;
+    const { estimates: estimateRef, callbacks: abrCallbacks } = representationEstimator({ manifest, period, adaptation }, currentRepresentation, representationsList, playbackObserver, adapStreamCanceller.signal);
     /** Allows a `RepresentationStream` to easily fetch media segments. */
-    var segmentFetcher = segmentFetcherCreator
+    const segmentFetcher = segmentFetcherCreator
         .createSegmentFetcher(adaptation.type, 
     /* eslint-disable @typescript-eslint/unbound-method */
     { onRequestBegin: abrCallbacks.requestBegin,
@@ -112,9 +77,8 @@ export default function AdaptationStream(_a, callbacks, parentCancelSignal) {
         onMetrics: abrCallbacks.metrics });
     /* eslint-enable @typescript-eslint/unbound-method */
     /** Used to determine when "fast-switching" is possible. */
-    var fastSwitchThreshold = createSharedReference(0);
-    estimateRef.onUpdate(function (_a) {
-        var bitrate = _a.bitrate, knownStableBitrate = _a.knownStableBitrate;
+    const fastSwitchThreshold = new reference_1.default(0);
+    estimateRef.onUpdate(({ bitrate, knownStableBitrate }) => {
         if (options.enableFastSwitching) {
             fastSwitchThreshold.setValueIfChanged(knownStableBitrate);
         }
@@ -122,25 +86,25 @@ export default function AdaptationStream(_a, callbacks, parentCancelSignal) {
             return;
         }
         previouslyEmittedBitrate = bitrate;
-        log.debug("Stream: new ".concat(adaptation.type, " bitrate estimate"), bitrate);
-        callbacks.bitrateEstimateChange({ type: adaptation.type, bitrate: bitrate });
+        log_1.default.debug(`Stream: new ${adaptation.type} bitrate estimate`, bitrate);
+        callbacks.bitrateEstimateChange({ type: adaptation.type, bitrate });
     }, { emitCurrentValue: true, clearSignal: adapStreamCanceller.signal });
     /**
      * When triggered, cancel all `RepresentationStream`s currently created.
      * Set to `undefined` initially.
      */
-    var cancelCurrentStreams;
+    let cancelCurrentStreams;
     // Each time the list of wanted Representations changes, we restart the logic
-    content.representations.onUpdate(function (val) {
+    content.representations.onUpdate((val) => {
         if (cancelCurrentStreams !== undefined) {
             cancelCurrentStreams.cancel();
         }
         representationsList.setValueIfChanged(val.representations);
-        cancelCurrentStreams = new TaskCanceller();
+        cancelCurrentStreams = new task_canceller_1.default();
         cancelCurrentStreams.linkToSignal(adapStreamCanceller.signal);
-        onRepresentationsChoiceChange(val, cancelCurrentStreams.signal).catch(function (err) {
+        onRepresentationsChoiceChange(val, cancelCurrentStreams.signal).catch((err) => {
             if ((cancelCurrentStreams === null || cancelCurrentStreams === void 0 ? void 0 : cancelCurrentStreams.isUsed()) === true &&
-                TaskCanceller.isCancellationError(err)) {
+                task_canceller_1.default.isCancellationError(err)) {
                 return;
             }
             adapStreamCanceller.cancel();
@@ -159,62 +123,50 @@ export default function AdaptationStream(_a, callbacks, parentCancelSignal) {
      * @param {Object} fnCancelSignal - `CancellationSignal` allowing to cancel
      * everything this function is doing and free all related resources.
      */
-    function onRepresentationsChoiceChange(choice, fnCancelSignal) {
-        return __awaiter(this, void 0, void 0, function () {
-            var switchStrat, _a, DELTA_POSITION_AFTER_RELOAD, bufferType_1, _i, _b, range;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        switchStrat = getRepresentationsSwitchingStrategy(period, adaptation, choice, segmentBuffer, playbackObserver);
-                        _a = switchStrat.type;
-                        switch (_a) {
-                            case "continue": return [3 /*break*/, 1];
-                            case "needs-reload": return [3 /*break*/, 2];
-                            case "flush-buffer": return [3 /*break*/, 3];
-                            case "clean-buffer": return [3 /*break*/, 3];
-                        }
-                        return [3 /*break*/, 8];
-                    case 1: return [3 /*break*/, 9]; // nothing to do
-                    case 2:
-                        DELTA_POSITION_AFTER_RELOAD = config.getCurrent().DELTA_POSITION_AFTER_RELOAD;
-                        bufferType_1 = adaptation.type;
-                        return [2 /*return*/, createReloadRequest(playbackObserver, function (_a) {
-                                var position = _a.position, autoPlay = _a.autoPlay;
-                                callbacks.waitingMediaSourceReload({ bufferType: bufferType_1, period: period, position: position, autoPlay: autoPlay });
-                            }, DELTA_POSITION_AFTER_RELOAD.bitrateSwitch, period, fnCancelSignal)];
-                    case 3:
-                        _i = 0, _b = switchStrat.value;
-                        _c.label = 4;
-                    case 4:
-                        if (!(_i < _b.length)) return [3 /*break*/, 7];
-                        range = _b[_i];
-                        return [4 /*yield*/, segmentBuffer.removeBuffer(range.start, range.end, fnCancelSignal)];
-                    case 5:
-                        _c.sent();
+    async function onRepresentationsChoiceChange(choice, fnCancelSignal) {
+        // First check if we should perform any action regarding what was previously
+        // in the buffer
+        const switchStrat = (0, get_representations_switch_strategy_1.default)(period, adaptation, choice, segmentBuffer, playbackObserver);
+        switch (switchStrat.type) {
+            case "continue":
+                break; // nothing to do
+            case "needs-reload": // Just ask to reload
+                // We begin by scheduling a micro-task to reduce the possibility of race
+                // conditions where the inner logic would be called synchronously before
+                // the next observation (which may reflect very different playback conditions)
+                // is actually received.
+                return (0, next_tick_1.default)(() => {
+                    playbackObserver.listen(() => {
                         if (fnCancelSignal.isCancelled()) {
-                            return [2 /*return*/];
+                            return;
                         }
-                        _c.label = 6;
-                    case 6:
-                        _i++;
-                        return [3 /*break*/, 4];
-                    case 7:
-                        if (switchStrat.type === "flush-buffer") {
-                            callbacks.needsBufferFlush();
-                            if (fnCancelSignal.isCancelled()) {
-                                return [2 /*return*/];
-                            }
-                        }
-                        return [3 /*break*/, 9];
-                    case 8:
-                        assertUnreachable(switchStrat);
-                        _c.label = 9;
-                    case 9:
-                        recursivelyCreateRepresentationStreams(fnCancelSignal);
-                        return [2 /*return*/];
+                        const { DELTA_POSITION_AFTER_RELOAD } = config_1.default.getCurrent();
+                        const timeOffset = DELTA_POSITION_AFTER_RELOAD.bitrateSwitch;
+                        return callbacks.waitingMediaSourceReload({ bufferType: adaptation.type,
+                            period,
+                            timeOffset,
+                            stayInPeriod: true });
+                    }, { includeLastObservation: true, clearSignal: fnCancelSignal });
+                });
+            case "flush-buffer": // Clean + flush
+            case "clean-buffer": // Just clean
+                for (const range of switchStrat.value) {
+                    await segmentBuffer.removeBuffer(range.start, range.end, fnCancelSignal);
+                    if (fnCancelSignal.isCancelled()) {
+                        return;
+                    }
                 }
-            });
-        });
+                if (switchStrat.type === "flush-buffer") {
+                    callbacks.needsBufferFlush();
+                    if (fnCancelSignal.isCancelled()) {
+                        return;
+                    }
+                }
+                break;
+            default: // Should be impossible
+                (0, assert_unreachable_1.default)(switchStrat);
+        }
+        recursivelyCreateRepresentationStreams(fnCancelSignal);
     }
     /**
      * Create `RepresentationStream`s starting with the Representation of the last
@@ -230,9 +182,9 @@ export default function AdaptationStream(_a, callbacks, parentCancelSignal) {
          * terminating and as such the next one might be immediately created
          * recursively.
          */
-        var repStreamTerminatingCanceller = new TaskCanceller();
+        const repStreamTerminatingCanceller = new task_canceller_1.default();
         repStreamTerminatingCanceller.linkToSignal(fnCancelSignal);
-        var representation = estimateRef.getValue().representation;
+        const { representation } = estimateRef.getValue();
         if (representation === null) {
             return;
         }
@@ -241,23 +193,23 @@ export default function AdaptationStream(_a, callbacks, parentCancelSignal) {
          * This allows to easily rely on that value in inner Observables which might also
          * need the last already-considered value.
          */
-        var terminateCurrentStream = createSharedReference(null, repStreamTerminatingCanceller.signal);
+        const terminateCurrentStream = new reference_1.default(null, repStreamTerminatingCanceller.signal);
         /** Allows to stop listening to estimateRef on the following line. */
-        estimateRef.onUpdate(function (estimate) {
+        estimateRef.onUpdate((estimate) => {
             if (estimate.representation === null ||
                 estimate.representation.id === representation.id) {
                 return;
             }
             if (estimate.urgent) {
-                log.info("Stream: urgent Representation switch", adaptation.type);
+                log_1.default.info("Stream: urgent Representation switch", adaptation.type);
                 return terminateCurrentStream.setValue({ urgent: true });
             }
             else {
-                log.info("Stream: slow Representation switch", adaptation.type);
+                log_1.default.info("Stream: slow Representation switch", adaptation.type);
                 return terminateCurrentStream.setValue({ urgent: false });
             }
         }, { clearSignal: repStreamTerminatingCanceller.signal, emitCurrentValue: true });
-        var repInfo = { type: adaptation.type, period: period, representation: representation };
+        const repInfo = { type: adaptation.type, period, representation };
         currentRepresentation.setValue(representation);
         if (adapStreamCanceller.isUsed()) {
             return; // previous callback has stopped everything by side-effect
@@ -266,25 +218,21 @@ export default function AdaptationStream(_a, callbacks, parentCancelSignal) {
         if (adapStreamCanceller.isUsed()) {
             return; // previous callback has stopped everything by side-effect
         }
-        var representationStreamCallbacks = {
+        const representationStreamCallbacks = {
             streamStatusUpdate: callbacks.streamStatusUpdate,
             encryptionDataEncountered: callbacks.encryptionDataEncountered,
             manifestMightBeOufOfSync: callbacks.manifestMightBeOufOfSync,
             needsManifestRefresh: callbacks.needsManifestRefresh,
             inbandEvent: callbacks.inbandEvent,
             warning: callbacks.warning,
-            error: function (err) {
+            error(err) {
                 adapStreamCanceller.cancel();
                 callbacks.error(err);
             },
-            addedSegment: function (segmentInfo) {
+            addedSegment(segmentInfo) {
                 abrCallbacks.addedSegment(segmentInfo);
-                if (adapStreamCanceller.isUsed()) {
-                    return;
-                }
-                callbacks.addedSegment(segmentInfo);
             },
-            terminating: function () {
+            terminating() {
                 if (repStreamTerminatingCanceller.isUsed()) {
                     return; // Already handled
                 }
@@ -307,19 +255,19 @@ export default function AdaptationStream(_a, callbacks, parentCancelSignal) {
      * anything this function is doing and free allocated resources.
      */
     function createRepresentationStream(representation, terminateCurrentStream, representationStreamCallbacks, fnCancelSignal) {
-        var bufferGoalCanceller = new TaskCanceller();
+        const bufferGoalCanceller = new task_canceller_1.default();
         bufferGoalCanceller.linkToSignal(fnCancelSignal);
-        var bufferGoal = createMappedReference(wantedBufferAhead, function (prev) {
+        const bufferGoal = (0, reference_1.createMappedReference)(wantedBufferAhead, prev => {
             return prev * getBufferGoalRatio(representation);
         }, bufferGoalCanceller.signal);
-        var maxBufferSize = adaptation.type === "video" ?
+        const maxBufferSize = adaptation.type === "video" ?
             maxVideoBufferSize :
-            createSharedReference(Infinity);
-        log.info("Stream: changing representation", adaptation.type, representation.id, representation.bitrate);
-        var updatedCallbacks = objectAssign({}, representationStreamCallbacks, {
-            error: function (err) {
+            new reference_1.default(Infinity);
+        log_1.default.info("Stream: changing representation", adaptation.type, representation.id, representation.bitrate);
+        const updatedCallbacks = (0, object_assign_1.default)({}, representationStreamCallbacks, {
+            error(err) {
                 var _a;
-                var formattedError = formatError(err, {
+                const formattedError = (0, errors_1.formatError)(err, {
                     defaultCode: "NONE",
                     defaultReason: "Unknown `RepresentationStream` error",
                 });
@@ -327,48 +275,58 @@ export default function AdaptationStream(_a, callbacks, parentCancelSignal) {
                     representationStreamCallbacks.error(err);
                 }
                 else {
-                    var wba = wantedBufferAhead.getValue();
-                    var lastBufferGoalRatio = (_a = bufferGoalRatioMap.get(representation.id)) !== null && _a !== void 0 ? _a : 1;
+                    const wba = wantedBufferAhead.getValue();
+                    const lastBufferGoalRatio = (_a = bufferGoalRatioMap.get(representation.id)) !== null && _a !== void 0 ? _a : 1;
                     // 70%, 49%, 34.3%, 24%, 16.81%, 11.76%, 8.24% and 5.76%
-                    var newBufferGoalRatio = lastBufferGoalRatio * 0.7;
+                    const newBufferGoalRatio = lastBufferGoalRatio * 0.7;
                     if (newBufferGoalRatio <= 0.05 || wba * newBufferGoalRatio <= 2) {
                         throw formattedError;
                     }
                     bufferGoalRatioMap.set(representation.id, newBufferGoalRatio);
                     // We wait 4 seconds to let the situation evolve by itself before
                     // retrying loading segments with a lower buffer goal
-                    cancellableSleep(4000, adapStreamCanceller.signal).then(function () {
+                    (0, cancellable_sleep_1.default)(4000, adapStreamCanceller.signal).then(() => {
                         return createRepresentationStream(representation, terminateCurrentStream, representationStreamCallbacks, fnCancelSignal);
-                    }).catch(noop);
+                    }).catch(noop_1.default);
                 }
             },
-            terminating: function () {
+            terminating() {
                 bufferGoalCanceller.cancel();
                 representationStreamCallbacks.terminating();
             },
         });
-        RepresentationStream({ playbackObserver: playbackObserver, content: { representation: representation, adaptation: adaptation, period: period, manifest: manifest }, segmentBuffer: segmentBuffer, segmentFetcher: segmentFetcher, terminate: terminateCurrentStream,
-            options: { bufferGoal: bufferGoal, maxBufferSize: maxBufferSize, drmSystemId: options.drmSystemId, fastSwitchThreshold: fastSwitchThreshold } }, updatedCallbacks, fnCancelSignal);
+        (0, representation_1.default)({ playbackObserver,
+            content: { representation,
+                adaptation,
+                period,
+                manifest },
+            segmentBuffer,
+            segmentFetcher,
+            terminate: terminateCurrentStream,
+            options: { bufferGoal,
+                maxBufferSize,
+                drmSystemId: options.drmSystemId,
+                fastSwitchThreshold } }, updatedCallbacks, fnCancelSignal);
         // reload if the Representation disappears from the Manifest
-        manifest.addEventListener("manifestUpdate", function (updates) {
-            for (var _i = 0, _a = updates.updatedPeriods; _i < _a.length; _i++) {
-                var element = _a[_i];
+        manifest.addEventListener("manifestUpdate", updates => {
+            for (const element of updates.updatedPeriods) {
                 if (element.period.id === period.id) {
-                    var _loop_1 = function (adap) {
-                        if (adap.id === adaptation.id) {
-                            var bufferType_2 = adaptation.type;
-                            return { value: createReloadRequest(playbackObserver, function (_a) {
-                                    var position = _a.position, autoPlay = _a.autoPlay;
-                                    callbacks
-                                        .waitingMediaSourceReload({ bufferType: bufferType_2, period: period, position: position, autoPlay: autoPlay });
-                                }, 0, period, fnCancelSignal) };
+                    for (const updated of element.result.updatedAdaptations) {
+                        if (updated.adaptation.id === adaptation.id) {
+                            for (const rep of updated.removedRepresentations) {
+                                if (rep.id === representation.id) {
+                                    if (fnCancelSignal.isCancelled()) {
+                                        return;
+                                    }
+                                    return callbacks.waitingMediaSourceReload({
+                                        bufferType: adaptation.type,
+                                        period,
+                                        timeOffset: 0,
+                                        stayInPeriod: true,
+                                    });
+                                }
+                            }
                         }
-                    };
-                    for (var _b = 0, _c = element.result.removedAdaptations; _b < _c.length; _b++) {
-                        var adap = _c[_b];
-                        var state_1 = _loop_1(adap);
-                        if (typeof state_1 === "object")
-                            return state_1.value;
                     }
                 }
                 else if (element.period.start > period.start) {
@@ -382,8 +340,8 @@ export default function AdaptationStream(_a, callbacks, parentCancelSignal) {
      * @returns {number}
      */
     function getBufferGoalRatio(representation) {
-        var oldBufferGoalRatio = bufferGoalRatioMap.get(representation.id);
-        var bufferGoalRatio = oldBufferGoalRatio !== undefined ? oldBufferGoalRatio :
+        const oldBufferGoalRatio = bufferGoalRatioMap.get(representation.id);
+        const bufferGoalRatio = oldBufferGoalRatio !== undefined ? oldBufferGoalRatio :
             1;
         if (oldBufferGoalRatio === undefined) {
             bufferGoalRatioMap.set(representation.id, bufferGoalRatio);
@@ -391,3 +349,4 @@ export default function AdaptationStream(_a, callbacks, parentCancelSignal) {
         return bufferGoalRatio;
     }
 }
+exports.default = AdaptationStream;

package/dist/_esm5.processed/core/stream/adaptation/get_representations_switch_strategy.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,56 +14,57 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import config from "../../../config";
-import { convertToRanges, excludeFromRanges, isTimeInRange, isTimeInRanges, keepRangeIntersection, } from "../../../utils/ranges";
-import { getFirstSegmentAfterPeriod, getLastSegmentBeforePeriod, } from "../../segment_buffers";
-export default function getRepresentationsSwitchingStrategy(period, adaptation, settings, segmentBuffer, playbackObserver) {
+Object.defineProperty(exports, "__esModule", { value: true });
+const config_1 = require("../../../config");
+const ranges_1 = require("../../../utils/ranges");
+const segment_buffers_1 = require("../../segment_buffers");
+function getRepresentationsSwitchingStrategy(period, adaptation, settings, segmentBuffer, playbackObserver) {
     if (settings.switchingMode === "lazy") {
         return { type: "continue", value: undefined };
     }
-    var buffered = segmentBuffer.getBufferedRanges();
+    const buffered = segmentBuffer.getBufferedRanges();
     if (buffered.length === 0) {
         return { type: "continue", value: undefined };
     }
-    var bufferedRanges = convertToRanges(buffered);
-    var start = period.start;
-    var end = period.end == null ? Infinity :
+    const bufferedRanges = (0, ranges_1.convertToRanges)(buffered);
+    const start = period.start;
+    const end = period.end == null ? Infinity :
         period.end;
-    var intersection = keepRangeIntersection(bufferedRanges, [{ start: start, end: end }]);
+    const intersection = (0, ranges_1.keepRangeIntersection)(bufferedRanges, [{ start, end }]);
     if (intersection.length === 0) {
         return { type: "continue", value: undefined };
     }
     segmentBuffer.synchronizeInventory();
-    var inventory = segmentBuffer.getInventory();
+    const inventory = segmentBuffer.getInventory();
     /** Data already in the right Adaptation */
-    var rangesWithReps = getBufferedRangesFromRepresentations(inventory, period, adaptation, settings.representations);
+    const rangesWithReps = getBufferedRangesFromRepresentations(inventory, period, adaptation, settings.representations);
     /**
      * Data different from the wanted Adaptation in the Period's range.
      * /!\ Could contain some data at the end of the previous Period or at the
      * beginning of the next one.
      */
-    var unwantedRange = excludeFromRanges(intersection, rangesWithReps);
+    const unwantedRange = (0, ranges_1.excludeFromRanges)(intersection, rangesWithReps);
     if (unwantedRange.length === 0) {
         return { type: "continue", value: undefined };
     }
-    var currentTime = playbackObserver.getCurrentTime();
-    var readyState = playbackObserver.getReadyState();
+    const currentTime = playbackObserver.getCurrentTime();
+    const readyState = playbackObserver.getReadyState();
     if (settings.switchingMode === "reload" &&
         // We're playing the current Period
-        isTimeInRange({ start: start, end: end }, currentTime) &&
+        (0, ranges_1.isTimeInRange)({ start, end }, currentTime) &&
         // There is data for the current position
         readyState > 1 &&
         // We're not playing the current wanted video Adaptation
-        !isTimeInRanges(rangesWithReps, currentTime)) {
+        !(0, ranges_1.isTimeInRanges)(rangesWithReps, currentTime)) {
         return { type: "needs-reload", value: undefined };
     }
     // From here, clean-up data from the previous Adaptation, if one
-    var shouldFlush = settings.switchingMode === "direct";
-    var rangesToExclude = [];
+    const shouldFlush = settings.switchingMode === "direct";
+    const rangesToExclude = [];
     // First, we don't want to accidentally remove some segments from the previous
     // Period (which overlap a little with this one)
     /** Last segment before one for the current period. */
-    var lastSegmentBefore = getLastSegmentBeforePeriod(inventory, period);
+    const lastSegmentBefore = (0, segment_buffers_1.getLastSegmentBeforePeriod)(inventory, period);
     if (lastSegmentBefore !== null &&
         (lastSegmentBefore.bufferedEnd === undefined ||
             period.start - lastSegmentBefore.bufferedEnd < 1)) // Close to Period's start
@@ -74,14 +76,14 @@ export default function getRepresentationsSwitchingStrategy(period, adaptation,
     }
     if (!shouldFlush) {
         // exclude data around current position to avoid decoding issues
-        var ADAP_REP_SWITCH_BUFFER_PADDINGS = config.getCurrent().ADAP_REP_SWITCH_BUFFER_PADDINGS;
-        var bufferType = adaptation.type;
+        const { ADAP_REP_SWITCH_BUFFER_PADDINGS } = config_1.default.getCurrent();
+        const bufferType = adaptation.type;
         /** Ranges that won't be cleaned from the current buffer. */
-        var paddingBefore = ADAP_REP_SWITCH_BUFFER_PADDINGS[bufferType].before;
+        let paddingBefore = ADAP_REP_SWITCH_BUFFER_PADDINGS[bufferType].before;
         if (paddingBefore == null) {
             paddingBefore = 0;
         }
-        var paddingAfter = ADAP_REP_SWITCH_BUFFER_PADDINGS[bufferType].after;
+        let paddingAfter = ADAP_REP_SWITCH_BUFFER_PADDINGS[bufferType].after;
         if (paddingAfter == null) {
             paddingAfter = 0;
         }
@@ -92,7 +94,7 @@ export default function getRepresentationsSwitchingStrategy(period, adaptation,
     // next Period
     if (period.end !== undefined) {
         /** first segment after for the current period. */
-        var firstSegmentAfter = getFirstSegmentAfterPeriod(inventory, period);
+        const firstSegmentAfter = (0, segment_buffers_1.getFirstSegmentAfterPeriod)(inventory, period);
         if (firstSegmentAfter !== null &&
             (firstSegmentAfter.bufferedStart === undefined ||
                 // Close to Period's end
@@ -101,13 +103,14 @@ export default function getRepresentationsSwitchingStrategy(period, adaptation,
                 end: Number.MAX_VALUE });
         }
     }
-    var toRemove = excludeFromRanges(unwantedRange, rangesToExclude);
+    const toRemove = (0, ranges_1.excludeFromRanges)(unwantedRange, rangesToExclude);
     if (toRemove.length === 0) {
         return { type: "continue", value: undefined };
     }
     return shouldFlush ? { type: "flush-buffer", value: toRemove } :
         { type: "clean-buffer", value: toRemove };
 }
+exports.default = getRepresentationsSwitchingStrategy;
 /**
  * Returns buffered ranges of what we know correspond to the given `adaptation`
  * in the SegmentBuffer.
@@ -117,13 +120,13 @@ export default function getRepresentationsSwitchingStrategy(period, adaptation,
  * @returns {Array.<Object>}
  */
 function getBufferedRangesFromRepresentations(inventory, period, adaptation, representations) {
-    return inventory.reduce(function (acc, chunk) {
+    return inventory.reduce((acc, chunk) => {
         if (chunk.infos.period.id !== period.id ||
             chunk.infos.adaptation.id !== adaptation.id ||
-            !representations.some(function (rep) { return rep.id === chunk.infos.representation.id; })) {
+            !representations.some(rep => rep.id === chunk.infos.representation.id)) {
             return acc;
         }
-        var bufferedStart = chunk.bufferedStart, bufferedEnd = chunk.bufferedEnd;
+        const { bufferedStart, bufferedEnd } = chunk;
         if (bufferedStart === undefined || bufferedEnd === undefined) {
             return acc;
         }

package/dist/_esm5.processed/core/stream/adaptation/index.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,6 +14,21 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import AdaptationStream from "./adaptation_stream";
-export * from "./types";
-export default AdaptationStream;
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const adaptation_stream_1 = require("./adaptation_stream");
+__exportStar(require("./types"), exports);
+exports.default = adaptation_stream_1.default;