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

package/dist/_esm5.processed/core/stream/orchestrator/stream_orchestrator.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,74 +14,18 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-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 };
-    }
-};
-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));
-};
-import nextTick from "next-tick";
-import config from "../../../config";
-import { MediaError } from "../../../errors";
-import log from "../../../log";
-import { createMappedReference, } from "../../../utils/reference";
-import SortedList from "../../../utils/sorted_list";
-import TaskCanceller from "../../../utils/task_canceller";
-import WeakMapMemory from "../../../utils/weak_map_memory";
-import { BufferGarbageCollector, } from "../../segment_buffers";
-import PeriodStream from "../period";
-import createReloadRequest from "../utils/create_reload_request";
-import getTimeRangesForContent from "./get_time_ranges_for_content";
+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 reference_1 = require("../../../utils/reference");
+const sorted_list_1 = require("../../../utils/sorted_list");
+const task_canceller_1 = require("../../../utils/task_canceller");
+const weak_map_memory_1 = require("../../../utils/weak_map_memory");
+const segment_buffers_1 = require("../../segment_buffers");
+const period_1 = require("../period");
+const get_time_ranges_for_content_1 = require("./get_time_ranges_for_content");
 /**
  * Create and manage the various "Streams" needed for the content to
  * play:
@@ -123,32 +68,29 @@ import getTimeRangesForContent from "./get_time_ranges_for_content";
  * when triggered, to immediately stop all operations the `PeriodStream` is
  * doing.
  */
-export default function StreamOrchestrator(content, playbackObserver, representationEstimator, segmentBuffersStore, segmentFetcherCreator, options, callbacks, orchestratorCancelSignal) {
-    var manifest = content.manifest, initialPeriod = content.initialPeriod;
-    var maxBufferAhead = options.maxBufferAhead, maxBufferBehind = options.maxBufferBehind, wantedBufferAhead = options.wantedBufferAhead, maxVideoBufferSize = options.maxVideoBufferSize;
-    var _a = config.getCurrent(), MAXIMUM_MAX_BUFFER_AHEAD = _a.MAXIMUM_MAX_BUFFER_AHEAD, MAXIMUM_MAX_BUFFER_BEHIND = _a.MAXIMUM_MAX_BUFFER_BEHIND;
+function StreamOrchestrator(content, playbackObserver, representationEstimator, segmentBuffersStore, segmentFetcherCreator, options, callbacks, orchestratorCancelSignal) {
+    const { manifest, initialPeriod } = content;
+    const { maxBufferAhead, maxBufferBehind, wantedBufferAhead, maxVideoBufferSize } = options;
+    const { MAXIMUM_MAX_BUFFER_AHEAD, MAXIMUM_MAX_BUFFER_BEHIND } = config_1.default.getCurrent();
     // Keep track of a unique BufferGarbageCollector created per
     // SegmentBuffer.
-    var garbageCollectors = new WeakMapMemory(function (segmentBuffer) {
-        var bufferType = segmentBuffer.bufferType;
-        var defaultMaxBehind = MAXIMUM_MAX_BUFFER_BEHIND[bufferType] != null ?
+    const garbageCollectors = new weak_map_memory_1.default((segmentBuffer) => {
+        const { bufferType } = segmentBuffer;
+        const defaultMaxBehind = MAXIMUM_MAX_BUFFER_BEHIND[bufferType] != null ?
             MAXIMUM_MAX_BUFFER_BEHIND[bufferType] :
             Infinity;
-        var defaultMaxAhead = MAXIMUM_MAX_BUFFER_AHEAD[bufferType] != null ?
+        const defaultMaxAhead = MAXIMUM_MAX_BUFFER_AHEAD[bufferType] != null ?
             MAXIMUM_MAX_BUFFER_AHEAD[bufferType] :
             Infinity;
-        return function (gcCancelSignal) {
-            BufferGarbageCollector({ segmentBuffer: segmentBuffer, playbackObserver: playbackObserver, maxBufferBehind: createMappedReference(maxBufferBehind, function (val) {
-                    return Math.min(val, defaultMaxBehind);
-                }, gcCancelSignal),
-                maxBufferAhead: createMappedReference(maxBufferAhead, function (val) {
-                    return Math.min(val, defaultMaxAhead);
-                }, gcCancelSignal) }, gcCancelSignal);
+        return (gcCancelSignal) => {
+            (0, segment_buffers_1.BufferGarbageCollector)({ segmentBuffer,
+                playbackObserver,
+                maxBufferBehind: (0, reference_1.createMappedReference)(maxBufferBehind, (val) => Math.min(val, defaultMaxBehind), gcCancelSignal),
+                maxBufferAhead: (0, reference_1.createMappedReference)(maxBufferAhead, (val) => Math.min(val, defaultMaxAhead), gcCancelSignal) }, gcCancelSignal);
         };
     });
     // Create automatically the right `PeriodStream` for every possible types
-    for (var _i = 0, _b = segmentBuffersStore.getBufferTypes(); _i < _b.length; _i++) {
-        var bufferType = _b[_i];
+    for (const bufferType of segmentBuffersStore.getBufferTypes()) {
         manageEveryStreams(bufferType, initialPeriod);
     }
     /**
@@ -162,7 +104,7 @@ export default function StreamOrchestrator(content, playbackObserver, representa
      */
     function manageEveryStreams(bufferType, basePeriod) {
         /** Each Period for which there is currently a Stream, chronologically */
-        var periodList = new SortedList(function (a, b) { return a.start - b.start; });
+        const periodList = new sorted_list_1.default((a, b) => a.start - b.start);
         /**
          * When set to `true`, all the currently active PeriodStream will be destroyed
          * and re-created from the new current position if we detect it to be out of
@@ -170,41 +112,40 @@ export default function StreamOrchestrator(content, playbackObserver, representa
          * This is set to false when we're in the process of creating the first
          * PeriodStream, to avoid interferences while no PeriodStream is available.
          */
-        var enableOutOfBoundsCheck = false;
+        let enableOutOfBoundsCheck = false;
         /** Cancels currently created `PeriodStream`s. */
-        var currentCanceller = new TaskCanceller();
+        let currentCanceller = new task_canceller_1.default();
         currentCanceller.linkToSignal(orchestratorCancelSignal);
         // Restart the current Stream when the wanted time is in another period
         // than the ones already considered
-        playbackObserver.listen(function (_a) {
-            var _b, _c;
-            var position = _a.position;
-            var time = (_b = position.pending) !== null && _b !== void 0 ? _b : position.last;
+        playbackObserver.listen(({ position }) => {
+            var _a, _b;
+            const time = (_a = position.pending) !== null && _a !== void 0 ? _a : position.last;
             if (!enableOutOfBoundsCheck || !isOutOfPeriodList(time)) {
                 return;
             }
-            log.info("Stream: Destroying all PeriodStreams due to out of bounds situation", bufferType, time);
+            log_1.default.info("Stream: Destroying all PeriodStreams due to out of bounds situation", bufferType, time);
             enableOutOfBoundsCheck = false;
             while (periodList.length() > 0) {
-                var period = periodList.get(periodList.length() - 1);
+                const period = periodList.get(periodList.length() - 1);
                 periodList.removeElement(period);
-                callbacks.periodStreamCleared({ type: bufferType, manifest: manifest, period: period });
+                callbacks.periodStreamCleared({ type: bufferType, manifest, period });
             }
             currentCanceller.cancel();
-            currentCanceller = new TaskCanceller();
+            currentCanceller = new task_canceller_1.default();
             currentCanceller.linkToSignal(orchestratorCancelSignal);
-            var nextPeriod = (_c = manifest.getPeriodForTime(time)) !== null && _c !== void 0 ? _c : manifest.getNextPeriod(time);
+            const nextPeriod = (_b = manifest.getPeriodForTime(time)) !== null && _b !== void 0 ? _b : manifest.getNextPeriod(time);
             if (nextPeriod === undefined) {
-                log.warn("Stream: The wanted position is not found in the Manifest.");
+                log_1.default.warn("Stream: The wanted position is not found in the Manifest.");
                 return;
             }
             launchConsecutiveStreamsForPeriod(nextPeriod);
         }, { clearSignal: orchestratorCancelSignal, includeLastObservation: true });
-        manifest.addEventListener("decipherabilityUpdate", function (evt) {
+        manifest.addEventListener("decipherabilityUpdate", (evt) => {
             if (orchestratorCancelSignal.isCancelled()) {
                 return;
             }
-            onDecipherabilityUpdates(evt).catch(function (err) {
+            onDecipherabilityUpdates(evt).catch(err => {
                 if (orchestratorCancelSignal.isCancelled()) {
                     return;
                 }
@@ -217,27 +158,33 @@ export default function StreamOrchestrator(content, playbackObserver, representa
          * @param {Object} period
          */
         function launchConsecutiveStreamsForPeriod(period) {
-            var consecutivePeriodStreamCb = __assign(__assign({}, callbacks), { waitingMediaSourceReload: function (payload) {
+            const consecutivePeriodStreamCb = Object.assign(Object.assign({}, callbacks), { waitingMediaSourceReload(payload) {
                     // Only reload the MediaSource when the more immediately required
                     // Period is the one it is asked for
-                    var firstPeriod = periodList.head();
+                    const firstPeriod = periodList.head();
                     if (firstPeriod === undefined ||
                         firstPeriod.id !== payload.period.id) {
                         callbacks.lockedStream({ bufferType: payload.bufferType,
                             period: payload.period });
                     }
                     else {
-                        var position = payload.position, autoPlay = payload.autoPlay;
-                        callbacks.needsMediaSourceReload({ position: position, autoPlay: autoPlay });
+                        callbacks.needsMediaSourceReload({
+                            timeOffset: payload.timeOffset,
+                            minimumPosition: payload.stayInPeriod ? payload.period.start : undefined,
+                            maximumPosition: payload.stayInPeriod ? payload.period.end : undefined,
+                        });
                     }
-                }, periodStreamReady: function (payload) {
+                },
+                periodStreamReady(payload) {
                     enableOutOfBoundsCheck = true;
                     periodList.add(payload.period);
                     callbacks.periodStreamReady(payload);
-                }, periodStreamCleared: function (payload) {
+                },
+                periodStreamCleared(payload) {
                     periodList.removeElement(payload.period);
                     callbacks.periodStreamCleared(payload);
-                }, error: function (err) {
+                },
+                error(err) {
                     currentCanceller.cancel();
                     callbacks.error(err);
                 } });
@@ -251,8 +198,8 @@ export default function StreamOrchestrator(content, playbackObserver, representa
          * @returns {boolean}
          */
         function isOutOfPeriodList(time) {
-            var head = periodList.head();
-            var last = periodList.last();
+            const head = periodList.head();
+            const last = periodList.last();
             if (head == null || last == null) { // if no period
                 return true;
             }
@@ -265,95 +212,87 @@ export default function StreamOrchestrator(content, playbackObserver, representa
          * @param {Array.<Object>}
          * @returns {Promise}
          */
-        function onDecipherabilityUpdates(updates) {
-            return __awaiter(this, void 0, void 0, function () {
-                var segmentBufferStatus, ofCurrentType, segmentBuffer, resettedContent, undecipherableContent, undecipherableRanges, rangesToRemove, period, _i, _a, _b, start, end;
-                return __generator(this, function (_c) {
-                    switch (_c.label) {
-                        case 0:
-                            segmentBufferStatus = segmentBuffersStore.getStatus(bufferType);
-                            ofCurrentType = updates
-                                .filter(function (update) { return update.adaptation.type === bufferType; });
-                            if (
-                            // No update concerns the current type of data
-                            ofCurrentType.length === 0 ||
-                                segmentBufferStatus.type !== "initialized" ||
-                                // The update only notifies of now-decipherable streams
-                                ofCurrentType.every(function (x) { return x.representation.decipherable === true; })) {
-                                // Data won't have to be removed from the buffers, no need to stop the
-                                // current Streams.
-                                return [2 /*return*/];
-                            }
-                            segmentBuffer = segmentBufferStatus.value;
-                            resettedContent = ofCurrentType.filter(function (update) {
-                                return update.representation.decipherable === undefined;
-                            });
-                            undecipherableContent = ofCurrentType.filter(function (update) {
-                                return update.representation.decipherable === false;
-                            });
-                            undecipherableRanges = getTimeRangesForContent(segmentBuffer, undecipherableContent);
-                            rangesToRemove = getTimeRangesForContent(segmentBuffer, resettedContent);
-                            // First close all Stream currently active so they don't continue to
-                            // load and push segments.
-                            enableOutOfBoundsCheck = false;
-                            log.info("Stream: Destroying all PeriodStreams for decipherability matters", bufferType);
-                            while (periodList.length() > 0) {
-                                period = periodList.get(periodList.length() - 1);
-                                periodList.removeElement(period);
-                                callbacks.periodStreamCleared({ type: bufferType, manifest: manifest, period: period });
-                            }
-                            currentCanceller.cancel();
-                            currentCanceller = new TaskCanceller();
-                            currentCanceller.linkToSignal(orchestratorCancelSignal);
-                            _i = 0, _a = __spreadArray(__spreadArray([], undecipherableRanges, true), rangesToRemove, true);
-                            _c.label = 1;
-                        case 1:
-                            if (!(_i < _a.length)) return [3 /*break*/, 4];
-                            _b = _a[_i], start = _b.start, end = _b.end;
-                            if (!(start < end)) return [3 /*break*/, 3];
-                            return [4 /*yield*/, segmentBuffer.removeBuffer(start, end, orchestratorCancelSignal)];
-                        case 2:
-                            _c.sent();
-                            _c.label = 3;
-                        case 3:
-                            _i++;
-                            return [3 /*break*/, 1];
-                        case 4:
-                            // Schedule micro task before checking the last playback observation
-                            // to reduce the risk of race conditions where the next observation
-                            // was going to be emitted synchronously.
-                            nextTick(function () {
-                                var _a, _b;
-                                if (orchestratorCancelSignal.isCancelled()) {
-                                    return;
-                                }
-                                var observation = playbackObserver.getReference().getValue();
-                                if (needsFlushingAfterClean(observation, undecipherableRanges)) {
-                                    var shouldAutoPlay = !((_a = observation.paused.pending) !== null && _a !== void 0 ? _a : playbackObserver.getIsPaused());
-                                    callbacks.needsDecipherabilityFlush({ position: observation.position.last,
-                                        autoPlay: shouldAutoPlay,
-                                        duration: observation.duration });
-                                    if (orchestratorCancelSignal.isCancelled()) {
-                                        return;
-                                    }
-                                }
-                                else if (needsFlushingAfterClean(observation, rangesToRemove)) {
-                                    callbacks.needsBufferFlush();
-                                    if (orchestratorCancelSignal.isCancelled()) {
-                                        return;
-                                    }
-                                }
-                                var lastPosition = (_b = observation.position.pending) !== null && _b !== void 0 ? _b : observation.position.last;
-                                var newInitialPeriod = manifest.getPeriodForTime(lastPosition);
-                                if (newInitialPeriod == null) {
-                                    callbacks.error(new MediaError("MEDIA_TIME_NOT_FOUND", "The wanted position is not found in the Manifest."));
-                                    return;
-                                }
-                                launchConsecutiveStreamsForPeriod(newInitialPeriod);
-                            });
-                            return [2 /*return*/];
+        async function onDecipherabilityUpdates(updates) {
+            const segmentBufferStatus = segmentBuffersStore.getStatus(bufferType);
+            const ofCurrentType = updates
+                .filter(update => update.adaptation.type === bufferType);
+            if (
+            // No update concerns the current type of data
+            ofCurrentType.length === 0 ||
+                segmentBufferStatus.type !== "initialized" ||
+                // The update only notifies of now-decipherable streams
+                ofCurrentType.every(x => x.representation.decipherable === true)) {
+                // Data won't have to be removed from the buffers, no need to stop the
+                // current Streams.
+                return;
+            }
+            const segmentBuffer = segmentBufferStatus.value;
+            const resettedContent = ofCurrentType.filter(update => update.representation.decipherable === undefined);
+            const undecipherableContent = ofCurrentType.filter(update => update.representation.decipherable === false);
+            /**
+             * Time ranges now containing undecipherable content.
+             * Those should first be removed and, depending on the platform, may
+             * need Supplementary actions as playback issues may remain even after
+             * removal.
+             */
+            const undecipherableRanges = (0, get_time_ranges_for_content_1.default)(segmentBuffer, undecipherableContent);
+            /**
+             * Time ranges now containing content whose decipherability status came
+             * back to being unknown.
+             * To simplify its handling, those are just removed from the buffer.
+             * Less considerations have to be taken than for the `undecipherableRanges`.
+             */
+            const rangesToRemove = (0, get_time_ranges_for_content_1.default)(segmentBuffer, resettedContent);
+            // First close all Stream currently active so they don't continue to
+            // load and push segments.
+            enableOutOfBoundsCheck = false;
+            log_1.default.info("Stream: Destroying all PeriodStreams for decipherability matters", bufferType);
+            while (periodList.length() > 0) {
+                const period = periodList.get(periodList.length() - 1);
+                periodList.removeElement(period);
+                callbacks.periodStreamCleared({ type: bufferType, manifest, period });
+            }
+            currentCanceller.cancel();
+            currentCanceller = new task_canceller_1.default();
+            currentCanceller.linkToSignal(orchestratorCancelSignal);
+            /** Remove from the `SegmentBuffer` all the concerned time ranges. */
+            for (const { start, end } of [...undecipherableRanges, ...rangesToRemove]) {
+                if (start < end) {
+                    if (orchestratorCancelSignal.isCancelled()) {
+                        return;
+                    }
+                    await segmentBuffer.removeBuffer(start, end, orchestratorCancelSignal);
+                }
+            }
+            // Schedule micro task before checking the last playback observation
+            // to reduce the risk of race conditions where the next observation
+            // was going to be emitted synchronously.
+            (0, next_tick_1.default)(() => {
+                var _a;
+                if (orchestratorCancelSignal.isCancelled()) {
+                    return;
+                }
+                const observation = playbackObserver.getReference().getValue();
+                if (needsFlushingAfterClean(observation, undecipherableRanges)) {
+                    // Bind to Period start and end
+                    callbacks.needsDecipherabilityFlush();
+                    if (orchestratorCancelSignal.isCancelled()) {
+                        return;
+                    }
+                }
+                else if (needsFlushingAfterClean(observation, rangesToRemove)) {
+                    callbacks.needsBufferFlush();
+                    if (orchestratorCancelSignal.isCancelled()) {
+                        return;
                     }
-                });
+                }
+                const lastPosition = (_a = observation.position.pending) !== null && _a !== void 0 ? _a : observation.position.last;
+                const newInitialPeriod = manifest.getPeriodForTime(lastPosition);
+                if (newInitialPeriod == null) {
+                    callbacks.error(new errors_1.MediaError("MEDIA_TIME_NOT_FOUND", "The wanted position is not found in the Manifest."));
+                    return;
+                }
+                launchConsecutiveStreamsForPeriod(newInitialPeriod);
             });
         }
     }
@@ -389,32 +328,42 @@ export default function StreamOrchestrator(content, playbackObserver, representa
      * signal emitting.
      */
     function manageConsecutivePeriodStreams(bufferType, basePeriod, consecutivePeriodStreamCb, cancelSignal) {
-        log.info("Stream: Creating new Stream for", bufferType, basePeriod.start);
+        log_1.default.info("Stream: Creating new Stream for", bufferType, basePeriod.start);
         /**
          * Contains properties linnked to the next chronological `PeriodStream` that
          * may be created here.
          */
-        var nextStreamInfo = null;
+        let nextStreamInfo = null;
         /** Emits when the `PeriodStream` linked to `basePeriod` should be destroyed. */
-        var currentStreamCanceller = new TaskCanceller();
+        const currentStreamCanceller = new task_canceller_1.default();
         currentStreamCanceller.linkToSignal(cancelSignal);
         // Stop current PeriodStream when the current position goes over the end of
         // that Period.
-        playbackObserver.listen(function (_a, stopListeningObservations) {
-            var _b, _c;
-            var position = _a.position;
+        playbackObserver.listen(({ position }, stopListeningObservations) => {
+            var _a, _b;
             if (basePeriod.end !== undefined &&
-                ((_b = position.pending) !== null && _b !== void 0 ? _b : position.last) >= basePeriod.end) {
-                log.info("Stream: Destroying PeriodStream as the current playhead moved above it", bufferType, basePeriod.start, (_c = position.pending) !== null && _c !== void 0 ? _c : position.last, basePeriod.end);
+                ((_a = position.pending) !== null && _a !== void 0 ? _a : position.last) >= basePeriod.end) {
+                log_1.default.info("Stream: Destroying PeriodStream as the current playhead moved above it", bufferType, basePeriod.start, (_b = position.pending) !== null && _b !== void 0 ? _b : position.last, basePeriod.end);
                 stopListeningObservations();
-                consecutivePeriodStreamCb.periodStreamCleared({ type: bufferType, manifest: manifest, period: basePeriod });
+                consecutivePeriodStreamCb.periodStreamCleared({ type: bufferType,
+                    manifest,
+                    period: basePeriod });
                 currentStreamCanceller.cancel();
             }
         }, { clearSignal: cancelSignal, includeLastObservation: true });
-        var periodStreamArgs = { bufferType: bufferType, content: { manifest: manifest, period: basePeriod }, garbageCollectors: garbageCollectors, maxVideoBufferSize: maxVideoBufferSize, segmentFetcherCreator: segmentFetcherCreator, segmentBuffersStore: segmentBuffersStore, options: options, playbackObserver: playbackObserver, representationEstimator: representationEstimator, wantedBufferAhead: wantedBufferAhead };
-        var periodStreamCallbacks = __assign(__assign({}, consecutivePeriodStreamCb), { streamStatusUpdate: function (value) {
+        const periodStreamArgs = { bufferType,
+            content: { manifest, period: basePeriod },
+            garbageCollectors,
+            maxVideoBufferSize,
+            segmentFetcherCreator,
+            segmentBuffersStore,
+            options,
+            playbackObserver,
+            representationEstimator,
+            wantedBufferAhead };
+        const periodStreamCallbacks = Object.assign(Object.assign({}, consecutivePeriodStreamCb), { streamStatusUpdate(value) {
                 if (value.hasFinishedLoading) {
-                    var nextPeriod = manifest.getPeriodAfter(basePeriod);
+                    const nextPeriod = manifest.getPeriodAfter(basePeriod);
                     if (nextPeriod !== null) {
                         // current Stream is full, create the next one if not
                         checkOrCreateNextPeriodStream(nextPeriod);
@@ -422,14 +371,17 @@ export default function StreamOrchestrator(content, playbackObserver, representa
                 }
                 else if (nextStreamInfo !== null) {
                     // current Stream is active, destroy next Stream if created
-                    log.info("Stream: Destroying next PeriodStream due to current one being active", bufferType, nextStreamInfo.period.start);
+                    log_1.default.info("Stream: Destroying next PeriodStream due to current one being active", bufferType, nextStreamInfo.period.start);
                     consecutivePeriodStreamCb
-                        .periodStreamCleared({ type: bufferType, manifest: manifest, period: nextStreamInfo.period });
+                        .periodStreamCleared({ type: bufferType,
+                        manifest,
+                        period: nextStreamInfo.period });
                     nextStreamInfo.canceller.cancel();
                     nextStreamInfo = null;
                 }
                 consecutivePeriodStreamCb.streamStatusUpdate(value);
-            }, error: function (err) {
+            },
+            error(err) {
                 if (nextStreamInfo !== null) {
                     nextStreamInfo.canceller.cancel();
                     nextStreamInfo = null;
@@ -437,7 +389,7 @@ export default function StreamOrchestrator(content, playbackObserver, representa
                 currentStreamCanceller.cancel();
                 consecutivePeriodStreamCb.error(err);
             } });
-        PeriodStream(periodStreamArgs, periodStreamCallbacks, currentStreamCanceller.signal);
+        (0, period_1.default)(periodStreamArgs, periodStreamCallbacks, currentStreamCanceller.signal);
         handleUnexpectedManifestUpdates(currentStreamCanceller.signal);
         /**
          * Create `PeriodStream` for the next Period, specified under `nextPeriod`.
@@ -448,11 +400,13 @@ export default function StreamOrchestrator(content, playbackObserver, representa
                 if (nextStreamInfo.period.id === nextPeriod.id) {
                     return;
                 }
-                log.warn("Stream: Creating next `PeriodStream` while one was already created.", bufferType, nextPeriod.id, nextStreamInfo.period.id);
-                consecutivePeriodStreamCb.periodStreamCleared({ type: bufferType, manifest: manifest, period: nextStreamInfo.period });
+                log_1.default.warn("Stream: Creating next `PeriodStream` while one was already created.", bufferType, nextPeriod.id, nextStreamInfo.period.id);
+                consecutivePeriodStreamCb.periodStreamCleared({ type: bufferType,
+                    manifest,
+                    period: nextStreamInfo.period });
                 nextStreamInfo.canceller.cancel();
             }
-            var nextStreamCanceller = new TaskCanceller();
+            const nextStreamCanceller = new task_canceller_1.default();
             nextStreamCanceller.linkToSignal(cancelSignal);
             nextStreamInfo = { canceller: nextStreamCanceller,
                 period: nextPeriod };
@@ -466,40 +420,43 @@ export default function StreamOrchestrator(content, playbackObserver, representa
          * performing checks.
          */
         function handleUnexpectedManifestUpdates(innerCancelSignal) {
-            manifest.addEventListener("manifestUpdate", function (updates) {
-                var _loop_1 = function (period) {
+            manifest.addEventListener("manifestUpdate", updates => {
+                // If current period has been unexpectedly removed, ask to reload
+                for (const period of updates.removedPeriods) {
                     if (period.id === basePeriod.id) {
                         // Check that this was not just one  of the earliests Periods that
                         // was removed, in which case this is a normal cleanup scenario
                         if (manifest.periods.length > 0 &&
                             manifest.periods[0].start <= period.start) {
-                            createReloadRequest(playbackObserver, function (_a) {
-                                var position = _a.position, autoPlay = _a.autoPlay;
-                                consecutivePeriodStreamCb
-                                    .waitingMediaSourceReload({ bufferType: bufferType, period: period, position: position, autoPlay: autoPlay });
-                            }, 0, { start: undefined, end: undefined }, innerCancelSignal);
+                            // 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)(() => {
+                                if (innerCancelSignal.isCancelled()) {
+                                    return;
+                                }
+                                return callbacks.needsMediaSourceReload({ timeOffset: 0,
+                                    minimumPosition: undefined,
+                                    maximumPosition: undefined });
+                            });
                         }
                     }
                     else if (period.start > basePeriod.start) {
-                        return "break";
-                    }
-                };
-                // If current period has been unexpectedly removed, ask to reload
-                for (var _i = 0, _a = updates.removedPeriods; _i < _a.length; _i++) {
-                    var period = _a[_i];
-                    var state_1 = _loop_1(period);
-                    if (state_1 === "break")
                         break;
+                    }
                 }
                 if (updates.addedPeriods.length > 0) {
                     // If the next period changed, cancel the next created one if one
                     if (nextStreamInfo !== null) {
-                        var newNextPeriod = manifest.getPeriodAfter(basePeriod);
+                        const newNextPeriod = manifest.getPeriodAfter(basePeriod);
                         if (newNextPeriod === null ||
                             nextStreamInfo.period.id !== newNextPeriod.id) {
-                            log.warn("Stream: Destroying next PeriodStream due to new one being added", bufferType, nextStreamInfo.period.start);
+                            log_1.default.warn("Stream: Destroying next PeriodStream due to new one being added", bufferType, nextStreamInfo.period.start);
                             consecutivePeriodStreamCb
-                                .periodStreamCleared({ type: bufferType, manifest: manifest, period: nextStreamInfo.period });
+                                .periodStreamCleared({ type: bufferType,
+                                manifest,
+                                period: nextStreamInfo.period });
                             nextStreamInfo.canceller.cancel();
                             nextStreamInfo = null;
                         }
@@ -509,6 +466,7 @@ export default function StreamOrchestrator(content, playbackObserver, representa
         }
     }
 }
+exports.default = StreamOrchestrator;
 /**
  * Returns `true` if low-level buffers have to be "flushed" after the given
  * `cleanedRanges` time ranges have been removed from an audio or video
@@ -521,7 +479,7 @@ function needsFlushingAfterClean(observation, cleanedRanges) {
     if (cleanedRanges.length === 0) {
         return false;
     }
-    var curPos = observation.position.last;
+    const curPos = observation.position.last;
     // Based on the playback direction, we just check whether we may encounter
     // the corresponding ranges, without seeking or re-switching playback
     // direction which is expected to lead to a low-level flush anyway.