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

package/dist/_esm5.processed/core/stream/period/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 PeriodStream from "./period_stream";
-export * from "./types";
-export default PeriodStream;
+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 period_stream_1 = require("./period_stream");
+__exportStar(require("./types"), exports);
+exports.default = period_stream_1.default;

package/dist/_esm5.processed/core/stream/period/period_stream.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,64 +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 };
-    }
-};
-import config from "../../../config";
-import { formatError, MediaError, } from "../../../errors";
-import log from "../../../log";
-import objectAssign from "../../../utils/object_assign";
-import { getLeftSizeOfRange } from "../../../utils/ranges";
-import createSharedReference from "../../../utils/reference";
-import TaskCanceller, { CancellationError, } from "../../../utils/task_canceller";
-import SegmentBuffersStore from "../../segment_buffers";
-import AdaptationStream from "../adaptation";
-import createReloadRequest from "../utils/create_reload_request";
-import getAdaptationSwitchStrategy from "./utils/get_adaptation_switch_strategy";
+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 object_assign_1 = require("../../../utils/object_assign");
+const ranges_1 = require("../../../utils/ranges");
+const reference_1 = require("../../../utils/reference");
+const task_canceller_1 = require("../../../utils/task_canceller");
+const segment_buffers_1 = require("../../segment_buffers");
+const adaptation_1 = require("../adaptation");
+const get_adaptation_switch_strategy_1 = require("./utils/get_adaptation_switch_strategy");
 /**
  * Create a single PeriodStream:
  *   - Lazily create (or reuse) a SegmentBuffer for the given type.
@@ -102,165 +57,133 @@ import getAdaptationSwitchStrategy from "./utils/get_adaptation_switch_strategy"
  * triggered, to immediately stop all operations the `PeriodStream` is
  * doing.
  */
-export default function PeriodStream(_a, callbacks, parentCancelSignal) {
-    var _this = this;
-    var bufferType = _a.bufferType, content = _a.content, garbageCollectors = _a.garbageCollectors, playbackObserver = _a.playbackObserver, representationEstimator = _a.representationEstimator, segmentFetcherCreator = _a.segmentFetcherCreator, segmentBuffersStore = _a.segmentBuffersStore, options = _a.options, wantedBufferAhead = _a.wantedBufferAhead, maxVideoBufferSize = _a.maxVideoBufferSize;
-    var manifest = content.manifest, period = content.period;
+function PeriodStream({ bufferType, content, garbageCollectors, playbackObserver, representationEstimator, segmentFetcherCreator, segmentBuffersStore, options, wantedBufferAhead, maxVideoBufferSize }, callbacks, parentCancelSignal) {
+    const { manifest, period } = content;
     /**
      * Emits the chosen Adaptation and Representations for the current type.
      * `null` when no Adaptation is chosen (e.g. no subtitles)
      * `undefined` at the beginning (it can be ignored.).
      */
-    var adaptationRef = createSharedReference(undefined, parentCancelSignal);
-    callbacks.periodStreamReady({ type: bufferType, manifest: manifest, period: period, adaptationRef: adaptationRef });
+    const adaptationRef = new reference_1.default(undefined, parentCancelSignal);
+    callbacks.periodStreamReady({ type: bufferType, manifest, period, adaptationRef });
     if (parentCancelSignal.isCancelled()) {
         return;
     }
-    var currentStreamCanceller;
-    var isFirstAdaptationSwitch = true;
-    adaptationRef.onUpdate(function (choice) {
+    let currentStreamCanceller;
+    let isFirstAdaptationSwitch = true;
+    adaptationRef.onUpdate((choice) => {
         // As an IIFE to profit from async/await while respecting onUpdate's signature
-        (function () { return __awaiter(_this, void 0, void 0, function () {
-            var streamCanceller, segmentBufferStatus, periodEnd, DELTA_POSITION_AFTER_RELOAD, relativePosAfterSwitch, adaptation, representations, readyState, segmentBuffer, playbackInfos, strategy, _i, _a, _b, start, end;
-            var _c;
-            return __generator(this, function (_d) {
-                switch (_d.label) {
-                    case 0:
-                        if (choice === undefined) {
-                            return [2 /*return*/];
-                        }
-                        streamCanceller = new TaskCanceller();
-                        streamCanceller.linkToSignal(parentCancelSignal);
-                        currentStreamCanceller === null || currentStreamCanceller === void 0 ? void 0 : currentStreamCanceller.cancel(); // Cancel oreviously created stream if one
-                        currentStreamCanceller = streamCanceller;
-                        if (!(choice === null)) return [3 /*break*/, 7];
-                        log.info("Stream: Set no ".concat(bufferType, " Adaptation. P:"), period.start);
-                        segmentBufferStatus = segmentBuffersStore.getStatus(bufferType);
-                        if (!(segmentBufferStatus.type === "initialized")) return [3 /*break*/, 5];
-                        log.info("Stream: Clearing previous ".concat(bufferType, " SegmentBuffer"));
-                        if (!SegmentBuffersStore.isNative(bufferType)) return [3 /*break*/, 1];
-                        return [2 /*return*/, createReloadRequest(playbackObserver, function (_a) {
-                                var position = _a.position, autoPlay = _a.autoPlay;
-                                callbacks
-                                    .waitingMediaSourceReload({ bufferType: bufferType, period: period, position: position, autoPlay: autoPlay });
-                            }, 0, period, streamCanceller.signal)];
-                    case 1:
-                        periodEnd = (_c = period.end) !== null && _c !== void 0 ? _c : Infinity;
-                        if (!(period.start > periodEnd)) return [3 /*break*/, 2];
-                        log.warn("Stream: Can't free buffer: period's start is after its end");
-                        return [3 /*break*/, 4];
-                    case 2: return [4 /*yield*/, segmentBufferStatus.value.removeBuffer(period.start, periodEnd, streamCanceller.signal)];
-                    case 3:
-                        _d.sent();
-                        if (streamCanceller.isUsed()) {
-                            return [2 /*return*/]; // The stream has been cancelled
+        (async () => {
+            var _a;
+            if (choice === undefined) {
+                return;
+            }
+            const streamCanceller = new task_canceller_1.default();
+            streamCanceller.linkToSignal(parentCancelSignal);
+            currentStreamCanceller === null || currentStreamCanceller === void 0 ? void 0 : currentStreamCanceller.cancel(); // Cancel oreviously created stream if one
+            currentStreamCanceller = streamCanceller;
+            if (choice === null) { // Current type is disabled for that Period
+                log_1.default.info(`Stream: Set no ${bufferType} Adaptation. P:`, period.start);
+                const segmentBufferStatus = segmentBuffersStore.getStatus(bufferType);
+                if (segmentBufferStatus.type === "initialized") {
+                    log_1.default.info(`Stream: Clearing previous ${bufferType} SegmentBuffer`);
+                    if (segment_buffers_1.default.isNative(bufferType)) {
+                        return askForMediaSourceReload(0, true, streamCanceller.signal);
+                    }
+                    else {
+                        const periodEnd = (_a = period.end) !== null && _a !== void 0 ? _a : Infinity;
+                        if (period.start > periodEnd) {
+                            log_1.default.warn("Stream: Can't free buffer: period's start is after its end");
                         }
-                        _d.label = 4;
-                    case 4: return [3 /*break*/, 6];
-                    case 5:
-                        if (segmentBufferStatus.type === "uninitialized") {
-                            segmentBuffersStore.disableSegmentBuffer(bufferType);
+                        else {
+                            await segmentBufferStatus.value.removeBuffer(period.start, periodEnd, streamCanceller.signal);
                             if (streamCanceller.isUsed()) {
-                                return [2 /*return*/]; // The stream has been cancelled
+                                return; // The stream has been cancelled
                             }
                         }
-                        _d.label = 6;
-                    case 6:
-                        callbacks.adaptationChange({ type: bufferType, adaptation: null, period: period });
-                        if (streamCanceller.isUsed()) {
-                            return [2 /*return*/]; // Previous call has provoken Stream cancellation by side-effect
-                        }
-                        return [2 /*return*/, createEmptyAdaptationStream(playbackObserver, wantedBufferAhead, bufferType, { period: period }, callbacks, streamCanceller.signal)];
-                    case 7:
-                        DELTA_POSITION_AFTER_RELOAD = config.getCurrent().DELTA_POSITION_AFTER_RELOAD;
-                        relativePosAfterSwitch = isFirstAdaptationSwitch ? 0 :
-                            bufferType === "audio" ? DELTA_POSITION_AFTER_RELOAD.trackSwitch.audio :
-                                bufferType === "video" ? DELTA_POSITION_AFTER_RELOAD.trackSwitch.video :
-                                    DELTA_POSITION_AFTER_RELOAD.trackSwitch.other;
-                        isFirstAdaptationSwitch = false;
-                        if (SegmentBuffersStore.isNative(bufferType) &&
-                            segmentBuffersStore.getStatus(bufferType).type === "disabled") {
-                            return [2 /*return*/, createReloadRequest(playbackObserver, function (_a) {
-                                    var position = _a.position, autoPlay = _a.autoPlay;
-                                    callbacks.waitingMediaSourceReload({ bufferType: bufferType, period: period, position: position, autoPlay: autoPlay });
-                                }, relativePosAfterSwitch, period, streamCanceller.signal)];
-                        }
-                        // Reload if the Adaptation disappears from the manifest
-                        manifest.addEventListener("manifestUpdate", function (updates) {
-                            // If current period has been unexpectedly removed, ask to reload
-                            for (var _i = 0, _a = updates.updatedPeriods; _i < _a.length; _i++) {
-                                var element = _a[_i];
-                                if (element.period.id === period.id) {
-                                    for (var _b = 0, _c = element.result.removedAdaptations; _b < _c.length; _b++) {
-                                        var adap = _c[_b];
-                                        if (adap.id === adaptation.id) {
-                                            return createReloadRequest(playbackObserver, function (_a) {
-                                                var position = _a.position, autoPlay = _a.autoPlay;
-                                                callbacks
-                                                    .waitingMediaSourceReload({ bufferType: bufferType, period: period, position: position, autoPlay: autoPlay });
-                                            }, relativePosAfterSwitch, period, streamCanceller.signal);
-                                        }
-                                    }
-                                }
-                                else if (element.period.start > period.start) {
-                                    break;
-                                }
-                            }
-                        }, currentStreamCanceller.signal);
-                        adaptation = choice.adaptation, representations = choice.representations;
-                        log.info("Stream: Updating ".concat(bufferType, " adaptation"), "A: ".concat(adaptation.id), "P: ".concat(period.start));
-                        callbacks.adaptationChange({ type: bufferType, adaptation: adaptation, period: period });
-                        if (streamCanceller.isUsed()) {
-                            return [2 /*return*/]; // Previous call has provoken cancellation by side-effect
-                        }
-                        readyState = playbackObserver.getReadyState();
-                        segmentBuffer = createOrReuseSegmentBuffer(segmentBuffersStore, bufferType, adaptation, options);
-                        playbackInfos = { currentTime: playbackObserver.getCurrentTime(), readyState: readyState };
-                        strategy = getAdaptationSwitchStrategy(segmentBuffer, period, adaptation, choice.switchingMode, playbackInfos, options);
-                        if (strategy.type === "needs-reload") {
-                            return [2 /*return*/, createReloadRequest(playbackObserver, function (_a) {
-                                    var position = _a.position, autoPlay = _a.autoPlay;
-                                    callbacks.waitingMediaSourceReload({ bufferType: bufferType, period: period, position: position, autoPlay: autoPlay });
-                                }, relativePosAfterSwitch, period, streamCanceller.signal)];
-                        }
-                        return [4 /*yield*/, segmentBuffersStore.waitForUsableBuffers(streamCanceller.signal)];
-                    case 8:
-                        _d.sent();
-                        if (streamCanceller.isUsed()) {
-                            return [2 /*return*/]; // The Stream has since been cancelled
-                        }
-                        if (!(strategy.type === "flush-buffer" || strategy.type === "clean-buffer")) return [3 /*break*/, 13];
-                        _i = 0, _a = strategy.value;
-                        _d.label = 9;
-                    case 9:
-                        if (!(_i < _a.length)) return [3 /*break*/, 12];
-                        _b = _a[_i], start = _b.start, end = _b.end;
-                        return [4 /*yield*/, segmentBuffer.removeBuffer(start, end, streamCanceller.signal)];
-                    case 10:
-                        _d.sent();
-                        if (streamCanceller.isUsed()) {
-                            return [2 /*return*/]; // The Stream has since been cancelled
-                        }
-                        _d.label = 11;
-                    case 11:
-                        _i++;
-                        return [3 /*break*/, 9];
-                    case 12:
-                        if (strategy.type === "flush-buffer") {
-                            callbacks.needsBufferFlush();
-                            if (streamCanceller.isUsed()) {
-                                return [2 /*return*/]; // Previous callback cancelled the Stream by side-effect
+                    }
+                }
+                else if (segmentBufferStatus.type === "uninitialized") {
+                    segmentBuffersStore.disableSegmentBuffer(bufferType);
+                    if (streamCanceller.isUsed()) {
+                        return; // The stream has been cancelled
+                    }
+                }
+                callbacks.adaptationChange({ type: bufferType, adaptation: null, period });
+                if (streamCanceller.isUsed()) {
+                    return; // Previous call has provoken Stream cancellation by side-effect
+                }
+                return createEmptyAdaptationStream(playbackObserver, wantedBufferAhead, bufferType, { period }, callbacks, streamCanceller.signal);
+            }
+            /**
+             * If this is not the first Adaptation choice, we might want to apply a
+             * delta to the current position so we can re-play back some media in the
+             * new Adaptation to give some context back.
+             * This value contains this relative position, in seconds.
+             * @see createMediaSourceReloadRequester
+             */
+            const { DELTA_POSITION_AFTER_RELOAD } = config_1.default.getCurrent();
+            const relativePosAfterSwitch = isFirstAdaptationSwitch ? 0 :
+                bufferType === "audio" ? DELTA_POSITION_AFTER_RELOAD.trackSwitch.audio :
+                    bufferType === "video" ? DELTA_POSITION_AFTER_RELOAD.trackSwitch.video :
+                        DELTA_POSITION_AFTER_RELOAD.trackSwitch.other;
+            isFirstAdaptationSwitch = false;
+            if (segment_buffers_1.default.isNative(bufferType) &&
+                segmentBuffersStore.getStatus(bufferType).type === "disabled") {
+                return askForMediaSourceReload(relativePosAfterSwitch, true, streamCanceller.signal);
+            }
+            // Reload if the Adaptation disappears from the manifest
+            manifest.addEventListener("manifestUpdate", updates => {
+                // If current period has been unexpectedly removed, ask to reload
+                for (const element of updates.updatedPeriods) {
+                    if (element.period.id === period.id) {
+                        for (const adap of element.result.removedAdaptations) {
+                            if (adap.id === adaptation.id) {
+                                return askForMediaSourceReload(relativePosAfterSwitch, true, streamCanceller.signal);
                             }
                         }
-                        _d.label = 13;
-                    case 13:
-                        garbageCollectors.get(segmentBuffer)(streamCanceller.signal);
-                        createAdaptationStream(adaptation, representations, segmentBuffer, streamCanceller.signal);
-                        return [2 /*return*/];
+                    }
+                    else if (element.period.start > period.start) {
+                        break;
+                    }
+                }
+            }, currentStreamCanceller.signal);
+            const { adaptation, representations } = choice;
+            log_1.default.info(`Stream: Updating ${bufferType} adaptation`, `A: ${adaptation.id}`, `P: ${period.start}`);
+            callbacks.adaptationChange({ type: bufferType, adaptation, period });
+            if (streamCanceller.isUsed()) {
+                return; // Previous call has provoken cancellation by side-effect
+            }
+            const readyState = playbackObserver.getReadyState();
+            const segmentBuffer = createOrReuseSegmentBuffer(segmentBuffersStore, bufferType, adaptation, options);
+            const playbackInfos = { currentTime: playbackObserver.getCurrentTime(),
+                readyState };
+            const strategy = (0, get_adaptation_switch_strategy_1.default)(segmentBuffer, period, adaptation, choice.switchingMode, playbackInfos, options);
+            if (strategy.type === "needs-reload") {
+                return askForMediaSourceReload(relativePosAfterSwitch, true, streamCanceller.signal);
+            }
+            await segmentBuffersStore.waitForUsableBuffers(streamCanceller.signal);
+            if (streamCanceller.isUsed()) {
+                return; // The Stream has since been cancelled
+            }
+            if (strategy.type === "flush-buffer" || strategy.type === "clean-buffer") {
+                for (const { start, end } of strategy.value) {
+                    await segmentBuffer.removeBuffer(start, end, streamCanceller.signal);
+                    if (streamCanceller.isUsed()) {
+                        return; // The Stream has since been cancelled
+                    }
+                }
+                if (strategy.type === "flush-buffer") {
+                    callbacks.needsBufferFlush();
+                    if (streamCanceller.isUsed()) {
+                        return; // Previous callback cancelled the Stream by side-effect
+                    }
                 }
-            });
-        }); })().catch(function (err) {
-            if (err instanceof CancellationError) {
+            }
+            garbageCollectors.get(segmentBuffer)(streamCanceller.signal);
+            createAdaptationStream(adaptation, representations, segmentBuffer, streamCanceller.signal);
+        })().catch((err) => {
+            if (err instanceof task_canceller_1.CancellationError) {
                 return;
             }
             currentStreamCanceller === null || currentStreamCanceller === void 0 ? void 0 : currentStreamCanceller.cancel();
@@ -274,16 +197,26 @@ export default function PeriodStream(_a, callbacks, parentCancelSignal) {
      * @param {Object} cancelSignal
      */
     function createAdaptationStream(adaptation, representations, segmentBuffer, cancelSignal) {
-        var adaptationPlaybackObserver = createAdaptationStreamPlaybackObserver(playbackObserver, segmentBuffer);
-        AdaptationStream({ content: { manifest: manifest, period: period, adaptation: adaptation, representations: representations }, options: options, playbackObserver: adaptationPlaybackObserver, representationEstimator: representationEstimator, segmentBuffer: segmentBuffer, segmentFetcherCreator: segmentFetcherCreator, wantedBufferAhead: wantedBufferAhead, maxVideoBufferSize: maxVideoBufferSize }, __assign(__assign({}, callbacks), { error: onAdaptationStreamError }), cancelSignal);
+        const adaptationPlaybackObserver = createAdaptationStreamPlaybackObserver(playbackObserver, segmentBuffer);
+        (0, adaptation_1.default)({ content: { manifest,
+                period,
+                adaptation,
+                representations },
+            options,
+            playbackObserver: adaptationPlaybackObserver,
+            representationEstimator,
+            segmentBuffer,
+            segmentFetcherCreator,
+            wantedBufferAhead,
+            maxVideoBufferSize }, Object.assign(Object.assign({}, callbacks), { error: onAdaptationStreamError }), cancelSignal);
         function onAdaptationStreamError(error) {
             // Stream linked to a non-native media buffer should not impact the
             // stability of the player. ie: if a text buffer sends an error, we want
             // to continue playing without any subtitles
-            if (!SegmentBuffersStore.isNative(bufferType)) {
-                log.error("Stream: ".concat(bufferType, " Stream crashed. Aborting it."), error instanceof Error ? error : "");
+            if (!segment_buffers_1.default.isNative(bufferType)) {
+                log_1.default.error(`Stream: ${bufferType} Stream crashed. Aborting it.`, error instanceof Error ? error : "");
                 segmentBuffersStore.disposeSegmentBuffer(bufferType);
-                var formattedError = formatError(error, {
+                const formattedError = (0, errors_1.formatError)(error, {
                     defaultCode: "NONE",
                     defaultReason: "Unknown `AdaptationStream` error",
                 });
@@ -291,27 +224,65 @@ export default function PeriodStream(_a, callbacks, parentCancelSignal) {
                 if (cancelSignal.isCancelled()) {
                     return; // Previous callback cancelled the Stream by side-effect
                 }
-                return createEmptyAdaptationStream(playbackObserver, wantedBufferAhead, bufferType, { period: period }, callbacks, cancelSignal);
+                return createEmptyAdaptationStream(playbackObserver, wantedBufferAhead, bufferType, { period }, callbacks, cancelSignal);
             }
-            log.error("Stream: ".concat(bufferType, " Stream crashed. Stopping playback."), error instanceof Error ? error : "");
+            log_1.default.error(`Stream: ${bufferType} Stream crashed. Stopping playback.`, error instanceof Error ? error : "");
             callbacks.error(error);
         }
     }
+    /**
+     * Regularly ask to reload the MediaSource on each playback observation
+     * performed by the playback observer.
+     *
+     * @param {number} timeOffset - Relative position, compared to the current
+     * playhead, at which we should restart playback after reloading.
+     * For example `-2` will reload 2 seconds before the current position.
+     * @param {boolean} stayInPeriod - If `true`, we will control that the position
+     * we reload at, after applying `timeOffset`, is still part of the Period
+     * `period`.
+     *
+     * If it isn't we will re-calculate that reloaded position to be:
+     *   - either the Period's start if the calculated position is before the
+     *     Period's start.
+     *   - either the Period'end start if the calculated position is after the
+     *     Period's end.
+     * @param {Object} cancelSignal
+     */
+    function askForMediaSourceReload(timeOffset, stayInPeriod, cancelSignal) {
+        // We begin by scheduling a micro-task to reduce the possibility of race
+        // conditions where `askForMediaSourceReload` would be called synchronously before
+        // the next observation (which may reflect very different playback conditions)
+        // is actually received.
+        // It can happen when `askForMediaSourceReload` is called as a side-effect of
+        // the same event that triggers the playback observation to be emitted.
+        (0, next_tick_1.default)(() => {
+            playbackObserver.listen(() => {
+                if (cancelSignal.isCancelled()) {
+                    return;
+                }
+                callbacks.waitingMediaSourceReload({ bufferType,
+                    period,
+                    timeOffset,
+                    stayInPeriod });
+            }, { includeLastObservation: true, clearSignal: cancelSignal });
+        });
+    }
 }
+exports.default = PeriodStream;
 /**
  * @param {string} bufferType
  * @param {Object} adaptation
  * @returns {Object}
  */
 function createOrReuseSegmentBuffer(segmentBuffersStore, bufferType, adaptation, options) {
-    var segmentBufferStatus = segmentBuffersStore.getStatus(bufferType);
+    const segmentBufferStatus = segmentBuffersStore.getStatus(bufferType);
     if (segmentBufferStatus.type === "initialized") {
-        log.info("Stream: Reusing a previous SegmentBuffer for the type", bufferType);
+        log_1.default.info("Stream: Reusing a previous SegmentBuffer for the type", bufferType);
         // eslint-disable-next-line @typescript-eslint/no-unsafe-return
         return segmentBufferStatus.value;
     }
-    var codec = getFirstDeclaredMimeType(adaptation);
-    var sbOptions = bufferType === "text" ? options.textTrackOptions : undefined;
+    const codec = getFirstDeclaredMimeType(adaptation);
+    const sbOptions = bufferType === "text" ? options.textTrackOptions : undefined;
     // eslint-disable-next-line @typescript-eslint/no-unsafe-return
     return segmentBuffersStore.createSegmentBuffer(bufferType, codec, sbOptions);
 }
@@ -322,10 +293,10 @@ function createOrReuseSegmentBuffer(segmentBuffersStore, bufferType, adaptation,
  * @returns {string}
  */
 function getFirstDeclaredMimeType(adaptation) {
-    var representations = adaptation.getPlayableRepresentations();
+    const representations = adaptation.getPlayableRepresentations();
     if (representations.length === 0) {
-        var noRepErr = new MediaError("NO_PLAYABLE_REPRESENTATION", "No Representation in the chosen " +
-            adaptation.type + " Adaptation can be played", { adaptation: adaptation });
+        const noRepErr = new errors_1.MediaError("NO_PLAYABLE_REPRESENTATION", "No Representation in the chosen " +
+            adaptation.type + " Adaptation can be played", { adaptations: [adaptation] });
         throw noRepErr;
     }
     return representations[0].getMimeTypeString();
@@ -338,17 +309,17 @@ function getFirstDeclaredMimeType(adaptation) {
  */
 function createAdaptationStreamPlaybackObserver(initialPlaybackObserver, segmentBuffer) {
     return initialPlaybackObserver.deriveReadOnlyObserver(function transform(observationRef, cancellationSignal) {
-        var newRef = createSharedReference(constructAdaptationStreamPlaybackObservation(), cancellationSignal);
+        const newRef = new reference_1.default(constructAdaptationStreamPlaybackObservation(), cancellationSignal);
         observationRef.onUpdate(emitAdaptationStreamPlaybackObservation, {
             clearSignal: cancellationSignal,
             emitCurrentValue: false,
         });
         return newRef;
         function constructAdaptationStreamPlaybackObservation() {
-            var baseObservation = observationRef.getValue();
-            var buffered = segmentBuffer.getBufferedRanges();
-            var bufferGap = getLeftSizeOfRange(buffered, baseObservation.position.last);
-            return objectAssign({}, baseObservation, { bufferGap: bufferGap });
+            const baseObservation = observationRef.getValue();
+            const buffered = segmentBuffer.getBufferedRanges();
+            const bufferGap = (0, ranges_1.getLeftSizeOfBufferedTimeRange)(buffered, baseObservation.position.last);
+            return (0, object_assign_1.default)({}, baseObservation, { bufferGap });
         }
         function emitAdaptationStreamPlaybackObservation() {
             newRef.setValue(constructAdaptationStreamPlaybackObservation());
@@ -367,20 +338,25 @@ function createAdaptationStreamPlaybackObserver(initialPlaybackObserver, segment
  * @param {Object} cancelSignal
  */
 function createEmptyAdaptationStream(playbackObserver, wantedBufferAhead, bufferType, content, callbacks, cancelSignal) {
-    var period = content.period;
-    var hasFinishedLoading = false;
+    const { period } = content;
+    let hasFinishedLoading = false;
     wantedBufferAhead.onUpdate(sendStatus, { emitCurrentValue: false, clearSignal: cancelSignal });
     playbackObserver.listen(sendStatus, { includeLastObservation: false, clearSignal: cancelSignal });
     sendStatus();
     function sendStatus() {
-        var observation = playbackObserver.getReference().getValue();
-        var wba = wantedBufferAhead.getValue();
-        var position = observation.position.last;
+        const observation = playbackObserver.getReference().getValue();
+        const wba = wantedBufferAhead.getValue();
+        const position = observation.position.last;
         if (period.end !== undefined && position + wba >= period.end) {
-            log.debug("Stream: full \"empty\" AdaptationStream", bufferType);
+            log_1.default.debug("Stream: full \"empty\" AdaptationStream", bufferType);
             hasFinishedLoading = true;
         }
-        callbacks.streamStatusUpdate({ period: period, bufferType: bufferType, position: position, imminentDiscontinuity: null,
-            isEmptyStream: true, hasFinishedLoading: hasFinishedLoading, neededSegments: [] });
+        callbacks.streamStatusUpdate({ period,
+            bufferType,
+            position,
+            imminentDiscontinuity: null,
+            isEmptyStream: true,
+            hasFinishedLoading,
+            neededSegments: [] });
     }
 }

package/dist/_esm5.processed/core/stream/period/types.d.ts

@@ -1,5 +1,5 @@
 import Manifest, { Adaptation, Period } from "../../../manifest";
-import { IReadOnlySharedReference, ISharedReference } from "../../../utils/reference";
+import SharedReference, { IReadOnlySharedReference } from "../../../utils/reference";
 import { CancellationSignal } from "../../../utils/task_canceller";
 import WeakMapMemory from "../../../utils/weak_map_memory";
 import { IRepresentationEstimator } from "../../adaptive";
@@ -9,7 +9,7 @@ import SegmentBuffersStore, { IBufferType, ITextTrackSegmentBufferOptions, Segme
 import { IAdaptationChoice, IAdaptationStreamCallbacks, IAdaptationStreamOptions, IPausedPlaybackObservation } from "../adaptation";
 import { IPositionPlaybackObservation } from "../representation";
 /** Callbacks called by the `AdaptationStream` on various events. */
-export interface IPeriodStreamCallbacks extends IAdaptationStreamCallbacks<unknown> {
+export interface IPeriodStreamCallbacks extends IAdaptationStreamCallbacks {
     /**
      * Called when a new `PeriodStream` is ready to start but needs an Adaptation
      * (i.e. track) to be chosen first.
@@ -52,7 +52,7 @@ export interface IPeriodStreamReadyPayload {
      * It is set to `undefined` by default, you SHOULD NOT set it to `undefined`
      * yourself.
      */
-    adaptationRef: ISharedReference<IAdaptationChoice | null | undefined>;
+    adaptationRef: SharedReference<IAdaptationChoice | null | undefined>;
 }
 /** Playback observation required by the `PeriodStream`. */
 export interface IPeriodStreamPlaybackObservation {

package/dist/_esm5.processed/core/stream/period/types.js

@@ -1 +1,2 @@
-export {};
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });