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

package/dist/_esm5.processed/core/stream/period/utils/get_adaptation_switch_strategy.d.ts

@@ -16,22 +16,36 @@
 import { Adaptation, Period } from "../../../../manifest";
 import { SegmentBuffer } from "../../../segment_buffers";
 import { ITrackSwitchingMode } from "../../adaptation";
-export type IAdaptationSwitchStrategy = {
+export type IAdaptationSwitchStrategy = 
+/** Do nothing special. */
+{
     type: "continue";
     value: undefined;
-} | {
+} | 
+/**
+ * Clean the given ranges of time from the buffer, preferably avoiding time
+ * around the current position to continue playback smoothly.
+ */
+{
     type: "clean-buffer";
     value: Array<{
         start: number;
         end: number;
     }>;
-} | {
+} | 
+/**
+ * Clean the given ranges of time from the buffer and try to flush the buffer
+ * so that it is taken in account directly.
+ */
+{
     type: "flush-buffer";
     value: Array<{
         start: number;
         end: number;
     }>;
-} | {
+} | 
+/** Reload completely the media buffers. */
+{
     type: "needs-reload";
     value: undefined;
 };

package/dist/_esm5.processed/core/stream/period/utils/get_adaptation_switch_strategy.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,10 +14,11 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import config from "../../../../config";
-import areCodecsCompatible from "../../../../utils/are_codecs_compatible";
-import { convertToRanges, excludeFromRanges, isTimeInRange, isTimeInRanges, keepRangeIntersection, } from "../../../../utils/ranges";
-import { getFirstSegmentAfterPeriod, getLastSegmentBeforePeriod, } from "../../../segment_buffers";
+Object.defineProperty(exports, "__esModule", { value: true });
+const config_1 = require("../../../../config");
+const are_codecs_compatible_1 = require("../../../../utils/are_codecs_compatible");
+const ranges_1 = require("../../../../utils/ranges");
+const segment_buffers_1 = require("../../../segment_buffers");
 /**
  * Find out what to do when switching Adaptation, based on the current
  * situation.
@@ -26,60 +28,60 @@ import { getFirstSegmentAfterPeriod, getLastSegmentBeforePeriod, } from "../../.
  * @param {Object} playbackInfo
  * @returns {Object}
  */
-export default function getAdaptationSwitchStrategy(segmentBuffer, period, adaptation, switchingMode, playbackInfo, options) {
+function getAdaptationSwitchStrategy(segmentBuffer, period, adaptation, switchingMode, playbackInfo, options) {
     if (segmentBuffer.codec !== undefined &&
         options.onCodecSwitch === "reload" &&
         !hasCompatibleCodec(adaptation, segmentBuffer.codec)) {
         return { type: "needs-reload", 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();
     // Continue if we have no other Adaptation buffered in the current Period
-    if (!inventory.some(function (buf) { return buf.infos.period.id === period.id &&
-        buf.infos.adaptation.id !== adaptation.id; })) {
+    if (!inventory.some(buf => buf.infos.period.id === period.id &&
+        buf.infos.adaptation.id !== adaptation.id)) {
         return { type: "continue", value: undefined };
     }
     /** Data already in the right Adaptation */
-    var adaptationInBuffer = getBufferedRangesFromAdaptation(inventory, period, adaptation);
+    const adaptationInBuffer = getBufferedRangesFromAdaptation(inventory, period, adaptation);
     /**
      * 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, adaptationInBuffer);
+    const unwantedRange = (0, ranges_1.excludeFromRanges)(intersection, adaptationInBuffer);
     if (unwantedRange.length === 0) {
         return { type: "continue", value: undefined };
     }
-    var currentTime = playbackInfo.currentTime;
+    const { currentTime } = playbackInfo;
     if (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 or the codecs are differents
         (playbackInfo.readyState > 1 || !adaptation.getPlayableRepresentations()
-            .some(function (rep) { var _a; return areCodecsCompatible(rep.getMimeTypeString(), (_a = segmentBuffer.codec) !== null && _a !== void 0 ? _a : ""); })) &&
+            .some(rep => { var _a; return (0, are_codecs_compatible_1.default)(rep.getMimeTypeString(), (_a = segmentBuffer.codec) !== null && _a !== void 0 ? _a : ""); })) &&
         // We're not playing the current wanted video Adaptation
-        !isTimeInRanges(adaptationInBuffer, currentTime)) {
+        !(0, ranges_1.isTimeInRanges)(adaptationInBuffer, currentTime)) {
         return { type: "needs-reload", value: undefined };
     }
     // From here, clean-up data from the previous Adaptation, if one
-    var shouldCleanAll = switchingMode === "direct";
-    var rangesToExclude = [];
+    const shouldCleanAll = 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
@@ -90,14 +92,14 @@ export default function getAdaptationSwitchStrategy(segmentBuffer, period, adapt
             end: period.start + 1 });
     }
     // Next, exclude data around current position to avoid decoding issues
-    var bufferType = adaptation.type;
-    var ADAP_REP_SWITCH_BUFFER_PADDINGS = config.getCurrent().ADAP_REP_SWITCH_BUFFER_PADDINGS;
+    const bufferType = adaptation.type;
+    const { ADAP_REP_SWITCH_BUFFER_PADDINGS } = config_1.default.getCurrent();
     /** 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;
     }
@@ -109,7 +111,7 @@ export default function getAdaptationSwitchStrategy(segmentBuffer, period, adapt
     // 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 ||
                 (firstSegmentAfter.bufferedStart - period.end) < 1)) // Close to Period's end
@@ -118,7 +120,7 @@ export default function getAdaptationSwitchStrategy(segmentBuffer, period, adapt
                 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 };
     }
@@ -126,6 +128,7 @@ export default function getAdaptationSwitchStrategy(segmentBuffer, period, adapt
         { type: "flush-buffer", value: toRemove } :
         { type: "clean-buffer", value: toRemove };
 }
+exports.default = getAdaptationSwitchStrategy;
 /**
  * Returns `true` if at least one codec of the Representations in the given
  * Adaptation has a codec compatible with the given SegmentBuffer's codec.
@@ -134,9 +137,7 @@ export default function getAdaptationSwitchStrategy(segmentBuffer, period, adapt
  * @returns {boolean}
  */
 function hasCompatibleCodec(adaptation, segmentBufferCodec) {
-    return adaptation.getPlayableRepresentations().some(function (rep) {
-        return areCodecsCompatible(rep.getMimeTypeString(), segmentBufferCodec);
-    });
+    return adaptation.getPlayableRepresentations().some(rep => (0, are_codecs_compatible_1.default)(rep.getMimeTypeString(), segmentBufferCodec));
 }
 /**
  * Returns buffered ranges of what we know correspond to the given `adaptation`
@@ -147,12 +148,12 @@ function hasCompatibleCodec(adaptation, segmentBufferCodec) {
  * @returns {Array.<Object>}
  */
 function getBufferedRangesFromAdaptation(inventory, period, adaptation) {
-    return inventory.reduce(function (acc, chunk) {
+    return inventory.reduce((acc, chunk) => {
         if (chunk.infos.period.id !== period.id ||
             chunk.infos.adaptation.id !== adaptation.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/representation/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 RepresentationStream from "./representation_stream";
-export * from "./types";
-export default RepresentationStream;
+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 representation_stream_1 = require("./representation_stream");
+__exportStar(require("./types"), exports);
+exports.default = representation_stream_1.default;

package/dist/_esm5.processed/core/stream/representation/representation_stream.d.ts

@@ -50,4 +50,4 @@ import { IRepresentationStreamArguments, IRepresentationStreamCallbacks } from "
  * triggered, to immediately stop all operations the `RepresentationStream` is
  * doing.
  */
-export default function RepresentationStream<TSegmentDataType>({ content, options, playbackObserver, segmentBuffer, segmentFetcher, terminate }: IRepresentationStreamArguments<TSegmentDataType>, callbacks: IRepresentationStreamCallbacks<TSegmentDataType>, parentCancelSignal: CancellationSignal): void;
+export default function RepresentationStream<TSegmentDataType>({ content, options, playbackObserver, segmentBuffer, segmentFetcher, terminate }: IRepresentationStreamArguments<TSegmentDataType>, callbacks: IRepresentationStreamCallbacks, parentCancelSignal: CancellationSignal): void;

package/dist/_esm5.processed/core/stream/representation/representation_stream.js

@@ -1,3 +1,4 @@
+"use strict";
 /**
  * Copyright 2015 CANAL+ Group
  *
@@ -13,6 +14,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+Object.defineProperty(exports, "__esModule", { value: true });
 /**
  * This file allows to create RepresentationStreams.
  *
@@ -21,16 +23,16 @@
  * It chooses which segments should be downloaded according to the current
  * position and what is currently buffered.
  */
-import config from "../../../config";
-import log from "../../../log";
-import objectAssign from "../../../utils/object_assign";
-import { createSharedReference } from "../../../utils/reference";
-import TaskCanceller, { CancellationError, } from "../../../utils/task_canceller";
-import DownloadingQueue from "./utils/downloading_queue";
-import getBufferStatus from "./utils/get_buffer_status";
-import getSegmentPriority from "./utils/get_segment_priority";
-import pushInitSegment from "./utils/push_init_segment";
-import pushMediaSegment from "./utils/push_media_segment";
+const config_1 = require("../../../config");
+const log_1 = require("../../../log");
+const object_assign_1 = require("../../../utils/object_assign");
+const reference_1 = require("../../../utils/reference");
+const task_canceller_1 = require("../../../utils/task_canceller");
+const downloading_queue_1 = require("./utils/downloading_queue");
+const get_buffer_status_1 = require("./utils/get_buffer_status");
+const get_segment_priority_1 = require("./utils/get_segment_priority");
+const push_init_segment_1 = require("./utils/push_init_segment");
+const push_media_segment_1 = require("./utils/push_media_segment");
 /**
  * Perform the logic to load the right segments for the given Representation and
  * push them to the given `SegmentBuffer`.
@@ -66,40 +68,39 @@ import pushMediaSegment from "./utils/push_media_segment";
  * triggered, to immediately stop all operations the `RepresentationStream` is
  * doing.
  */
-export default function RepresentationStream(_a, callbacks, parentCancelSignal) {
-    var content = _a.content, options = _a.options, playbackObserver = _a.playbackObserver, segmentBuffer = _a.segmentBuffer, segmentFetcher = _a.segmentFetcher, terminate = _a.terminate;
-    var period = content.period, adaptation = content.adaptation, representation = content.representation;
-    var bufferGoal = options.bufferGoal, maxBufferSize = options.maxBufferSize, drmSystemId = options.drmSystemId, fastSwitchThreshold = options.fastSwitchThreshold;
-    var bufferType = adaptation.type;
+function RepresentationStream({ content, options, playbackObserver, segmentBuffer, segmentFetcher, terminate }, callbacks, parentCancelSignal) {
+    const { period, adaptation, representation } = content;
+    const { bufferGoal, maxBufferSize, drmSystemId, fastSwitchThreshold } = options;
+    const bufferType = adaptation.type;
     /** `TaskCanceller` stopping ALL operations performed by the `RepresentationStream` */
-    var globalCanceller = new TaskCanceller();
+    const globalCanceller = new task_canceller_1.default();
     globalCanceller.linkToSignal(parentCancelSignal);
     /**
      * `TaskCanceller` allowing to only stop segment loading and checking operations.
      * This allows to stop only tasks linked to network resource usage, which is
      * often a limited resource, while still letting buffer operations to finish.
      */
-    var segmentsLoadingCanceller = new TaskCanceller();
+    const segmentsLoadingCanceller = new task_canceller_1.default();
     segmentsLoadingCanceller.linkToSignal(globalCanceller.signal);
     /** Saved initialization segment state for this representation. */
-    var initSegmentState = {
+    const initSegmentState = {
         segment: representation.index.getInitSegment(),
         uniqueId: null,
         isLoaded: false,
     };
-    globalCanceller.signal.register(function () {
+    globalCanceller.signal.register(() => {
         // Free initialization segment if one has been declared
         if (initSegmentState.uniqueId !== null) {
             segmentBuffer.freeInitSegment(initSegmentState.uniqueId);
         }
     });
     /** Emit the last scheduled downloading queue for segments. */
-    var lastSegmentQueue = createSharedReference({
+    const lastSegmentQueue = new reference_1.default({
         initSegment: null,
         segmentQueue: [],
     }, segmentsLoadingCanceller.signal);
     /** If `true`, the current Representation has a linked initialization segment. */
-    var hasInitSegment = initSegmentState.segment !== null;
+    const hasInitSegment = initSegmentState.segment !== null;
     if (!hasInitSegment) {
         initSegmentState.isLoaded = true;
     }
@@ -108,25 +109,25 @@ export default function RepresentationStream(_a, callbacks, parentCancelSignal)
      * constructed.
      * Allows to avoid sending multiple times protection events.
      */
-    var hasSentEncryptionData = false;
+    let hasSentEncryptionData = false;
     // If the DRM system id is already known, and if we already have encryption data
     // for it, we may not need to wait until the initialization segment is loaded to
     // signal required protection data, thus performing License negotiations sooner
     if (drmSystemId !== undefined) {
-        var encryptionData = representation.getEncryptionData(drmSystemId);
+        const encryptionData = representation.getEncryptionData(drmSystemId);
         // If some key ids are not known yet, it may be safer to wait for this initialization
         // segment to be loaded first
-        if (encryptionData.length > 0 && encryptionData.every(function (e) { return e.keyIds !== undefined; })) {
+        if (encryptionData.length > 0 && encryptionData.every(e => e.keyIds !== undefined)) {
             hasSentEncryptionData = true;
-            callbacks.encryptionDataEncountered(encryptionData.map(function (d) { return objectAssign({ content: content }, d); }));
+            callbacks.encryptionDataEncountered(encryptionData.map(d => (0, object_assign_1.default)({ content }, d)));
             if (globalCanceller.isUsed()) {
                 return; // previous callback has stopped everything by side-effect
             }
         }
     }
     /** Will load every segments in `lastSegmentQueue` */
-    var downloadingQueue = new DownloadingQueue(content, lastSegmentQueue, segmentFetcher, hasInitSegment);
-    downloadingQueue.addEventListener("error", function (err) {
+    const downloadingQueue = new downloading_queue_1.default(content, lastSegmentQueue, segmentFetcher, hasInitSegment);
+    downloadingQueue.addEventListener("error", (err) => {
         if (segmentsLoadingCanceller.signal.isCancelled()) {
             return; // ignore post requests-cancellation loading-related errors,
         }
@@ -136,13 +137,13 @@ export default function RepresentationStream(_a, callbacks, parentCancelSignal)
     downloadingQueue.addEventListener("parsedInitSegment", onParsedChunk);
     downloadingQueue.addEventListener("parsedMediaSegment", onParsedChunk);
     downloadingQueue.addEventListener("emptyQueue", checkStatus);
-    downloadingQueue.addEventListener("requestRetry", function (payload) {
+    downloadingQueue.addEventListener("requestRetry", (payload) => {
         callbacks.warning(payload.error);
         if (segmentsLoadingCanceller.signal.isCancelled()) {
             return; // If the previous callback led to loading operations being stopped, skip
         }
-        var retriedSegment = payload.segment;
-        var index = representation.index;
+        const retriedSegment = payload.segment;
+        const { index } = representation;
         if (index.isSegmentStillAvailable(retriedSegment) === false) {
             checkStatus();
         }
@@ -150,12 +151,12 @@ export default function RepresentationStream(_a, callbacks, parentCancelSignal)
             callbacks.manifestMightBeOufOfSync();
         }
     });
-    downloadingQueue.addEventListener("fullyLoadedSegment", function (segment) {
-        segmentBuffer.endOfSegment(objectAssign({ segment: segment }, content), globalCanceller.signal)
+    downloadingQueue.addEventListener("fullyLoadedSegment", (segment) => {
+        segmentBuffer.endOfSegment((0, object_assign_1.default)({ segment }, content), globalCanceller.signal)
             .catch(onFatalBufferError);
     });
     downloadingQueue.start();
-    segmentsLoadingCanceller.signal.register(function () {
+    segmentsLoadingCanceller.signal.register(() => {
         downloadingQueue.removeEventListener();
         downloadingQueue.stop();
     });
@@ -163,6 +164,7 @@ export default function RepresentationStream(_a, callbacks, parentCancelSignal)
         includeLastObservation: false,
         clearSignal: segmentsLoadingCanceller.signal,
     });
+    content.manifest.addEventListener("manifestUpdate", checkStatus, segmentsLoadingCanceller.signal);
     bufferGoal.onUpdate(checkStatus, {
         emitCurrentValue: false,
         clearSignal: segmentsLoadingCanceller.signal,
@@ -187,40 +189,40 @@ export default function RepresentationStream(_a, callbacks, parentCancelSignal)
         if (segmentsLoadingCanceller.isUsed()) {
             return; // Stop all buffer status checking if load operations are stopped
         }
-        var observation = playbackObserver.getReference().getValue();
-        var initialWantedTime = (_a = observation.position.pending) !== null && _a !== void 0 ? _a : observation.position.last;
-        var status = getBufferStatus(content, initialWantedTime, playbackObserver, fastSwitchThreshold.getValue(), bufferGoal.getValue(), maxBufferSize.getValue(), segmentBuffer);
-        var neededSegments = status.neededSegments;
-        var neededInitSegment = null;
+        const observation = playbackObserver.getReference().getValue();
+        const initialWantedTime = (_a = observation.position.pending) !== null && _a !== void 0 ? _a : observation.position.last;
+        const status = (0, get_buffer_status_1.default)(content, initialWantedTime, playbackObserver, fastSwitchThreshold.getValue(), bufferGoal.getValue(), maxBufferSize.getValue(), segmentBuffer);
+        const { neededSegments } = status;
+        let neededInitSegment = null;
         // Add initialization segment if required
         if (!representation.index.isInitialized()) {
             if (initSegmentState.segment === null) {
-                log.warn("Stream: Uninitialized index without an initialization segment");
+                log_1.default.warn("Stream: Uninitialized index without an initialization segment");
             }
             else if (initSegmentState.isLoaded) {
-                log.warn("Stream: Uninitialized index with an already loaded " +
+                log_1.default.warn("Stream: Uninitialized index with an already loaded " +
                     "initialization segment");
             }
             else {
-                var wantedStart = (_b = observation.position.pending) !== null && _b !== void 0 ? _b : observation.position.last;
+                const wantedStart = (_b = observation.position.pending) !== null && _b !== void 0 ? _b : observation.position.last;
                 neededInitSegment = { segment: initSegmentState.segment,
-                    priority: getSegmentPriority(period.start, wantedStart) };
+                    priority: (0, get_segment_priority_1.default)(period.start, wantedStart) };
             }
         }
         else if (neededSegments.length > 0 &&
             !initSegmentState.isLoaded &&
             initSegmentState.segment !== null) {
-            var initSegmentPriority = neededSegments[0].priority;
+            const initSegmentPriority = neededSegments[0].priority;
             neededInitSegment = { segment: initSegmentState.segment,
                 priority: initSegmentPriority };
         }
-        var terminateVal = terminate.getValue();
+        const terminateVal = terminate.getValue();
         if (terminateVal === null) {
             lastSegmentQueue.setValue({ initSegment: neededInitSegment,
                 segmentQueue: neededSegments });
         }
         else if (terminateVal.urgent) {
-            log.debug("Stream: Urgent switch, terminate now.", bufferType);
+            log_1.default.debug("Stream: Urgent switch, terminate now.", bufferType);
             lastSegmentQueue.setValue({ initSegment: null, segmentQueue: [] });
             lastSegmentQueue.finish();
             segmentsLoadingCanceller.cancel();
@@ -232,36 +234,39 @@ export default function RepresentationStream(_a, callbacks, parentCancelSignal)
             // End the download of the current media segment if pending and
             // terminate once either that request is finished or another segment
             // is wanted instead, whichever comes first.
-            var mostNeededSegment = neededSegments[0];
-            var initSegmentRequest = downloadingQueue.getRequestedInitSegment();
-            var currentSegmentRequest = downloadingQueue.getRequestedMediaSegment();
-            var nextQueue = currentSegmentRequest === null ||
+            const mostNeededSegment = neededSegments[0];
+            const initSegmentRequest = downloadingQueue.getRequestedInitSegment();
+            const currentSegmentRequest = downloadingQueue.getRequestedMediaSegment();
+            const nextQueue = currentSegmentRequest === null ||
                 mostNeededSegment === undefined ||
                 currentSegmentRequest.id !== mostNeededSegment.segment.id ?
                 [] :
                 [mostNeededSegment];
-            var nextInit = initSegmentRequest === null ? null :
+            const nextInit = initSegmentRequest === null ? null :
                 neededInitSegment;
             lastSegmentQueue.setValue({ initSegment: nextInit,
                 segmentQueue: nextQueue });
             if (nextQueue.length === 0 && nextInit === null) {
-                log.debug("Stream: No request left, terminate", bufferType);
+                log_1.default.debug("Stream: No request left, terminate", bufferType);
                 lastSegmentQueue.finish();
                 segmentsLoadingCanceller.cancel();
                 callbacks.terminating();
                 return;
             }
         }
-        callbacks.streamStatusUpdate({ period: period, position: observation.position.last, bufferType: bufferType, imminentDiscontinuity: status.imminentDiscontinuity,
+        callbacks.streamStatusUpdate({ period,
+            position: observation.position.last,
+            bufferType,
+            imminentDiscontinuity: status.imminentDiscontinuity,
             isEmptyStream: false,
             hasFinishedLoading: status.hasFinishedLoading,
             neededSegments: status.neededSegments });
         if (segmentsLoadingCanceller.signal.isCancelled()) {
             return; // previous callback has stopped loading operations by side-effect
         }
-        var UPTO_CURRENT_POSITION_CLEANUP = config.getCurrent().UPTO_CURRENT_POSITION_CLEANUP;
+        const { UPTO_CURRENT_POSITION_CLEANUP } = config_1.default.getCurrent();
         if (status.isBufferFull) {
-            var gcedPosition = Math.max(0, initialWantedTime - UPTO_CURRENT_POSITION_CLEANUP);
+            const gcedPosition = Math.max(0, initialWantedTime - UPTO_CURRENT_POSITION_CLEANUP);
             if (gcedPosition > 0) {
                 segmentBuffer.removeBuffer(0, gcedPosition, globalCanceller.signal)
                     .catch(onFatalBufferError);
@@ -283,8 +288,7 @@ export default function RepresentationStream(_a, callbacks, parentCancelSignal)
             return;
         }
         // Supplementary encryption information might have been parsed.
-        for (var _i = 0, _a = evt.protectionData; _i < _a.length; _i++) {
-            var protInfo = _a[_i];
+        for (const protInfo of evt.protectionData) {
             // TODO better handle use cases like key rotation by not always grouping
             // every protection data together? To check.
             representation.addProtectionData(protInfo.initDataType, protInfo.keyId, protInfo.initData);
@@ -293,9 +297,9 @@ export default function RepresentationStream(_a, callbacks, parentCancelSignal)
         // included encryption information - take care of the encryption event
         // if not already done.
         if (!hasSentEncryptionData) {
-            var allEncryptionData = representation.getAllEncryptionData();
+            const allEncryptionData = representation.getAllEncryptionData();
             if (allEncryptionData.length > 0) {
-                callbacks.encryptionDataEncountered(allEncryptionData.map(function (p) { return objectAssign({ content: content }, p); }));
+                callbacks.encryptionDataEncountered(allEncryptionData.map(p => (0, object_assign_1.default)({ content }, p)));
                 hasSentEncryptionData = true;
                 // previous callback could have lead to cancellation
                 if (globalCanceller.isUsed()) {
@@ -310,12 +314,16 @@ export default function RepresentationStream(_a, callbacks, parentCancelSignal)
             }
             initSegmentState.isLoaded = true;
             if (evt.initializationData !== null) {
-                var initSegmentUniqueId = representation.uniqueId;
+                const initSegmentUniqueId = representation.uniqueId;
                 initSegmentState.uniqueId = initSegmentUniqueId;
                 segmentBuffer.declareInitSegment(initSegmentUniqueId, evt.initializationData);
-                pushInitSegment({ playbackObserver: playbackObserver, content: content, initSegmentUniqueId: initSegmentUniqueId, segment: evt.segment,
-                    segmentData: evt.initializationData, segmentBuffer: segmentBuffer }, globalCanceller.signal)
-                    .then(function (result) {
+                (0, push_init_segment_1.default)({ playbackObserver,
+                    content,
+                    initSegmentUniqueId,
+                    segment: evt.segment,
+                    segmentData: evt.initializationData,
+                    segmentBuffer }, globalCanceller.signal)
+                    .then((result) => {
                     if (result !== null) {
                         callbacks.addedSegment(result);
                     }
@@ -328,7 +336,7 @@ export default function RepresentationStream(_a, callbacks, parentCancelSignal)
             return;
         }
         else {
-            var inbandEvents = evt.inbandEvents, predictedSegments = evt.predictedSegments, needsManifestRefresh = evt.needsManifestRefresh;
+            const { inbandEvents, predictedSegments, needsManifestRefresh } = evt;
             if (predictedSegments !== undefined) {
                 representation.index.addPredictedSegments(predictedSegments, evt.segment);
             }
@@ -344,10 +352,14 @@ export default function RepresentationStream(_a, callbacks, parentCancelSignal)
                     return; // previous callback has stopped everything by side-effect
                 }
             }
-            var initSegmentUniqueId = initSegmentState.uniqueId;
-            pushMediaSegment({ playbackObserver: playbackObserver, content: content, initSegmentUniqueId: initSegmentUniqueId, parsedSegment: evt,
-                segment: evt.segment, segmentBuffer: segmentBuffer }, globalCanceller.signal)
-                .then(function (result) {
+            const initSegmentUniqueId = initSegmentState.uniqueId;
+            (0, push_media_segment_1.default)({ playbackObserver,
+                content,
+                initSegmentUniqueId,
+                parsedSegment: evt,
+                segment: evt.segment,
+                segmentBuffer }, globalCanceller.signal)
+                .then((result) => {
                 if (result !== null) {
                     callbacks.addedSegment(result);
                 }
@@ -362,7 +374,7 @@ export default function RepresentationStream(_a, callbacks, parentCancelSignal)
      * @param {*} err
      */
     function onFatalBufferError(err) {
-        if (globalCanceller.isUsed() && err instanceof CancellationError) {
+        if (globalCanceller.isUsed() && err instanceof task_canceller_1.CancellationError) {
             // The error is linked to cancellation AND we explicitely cancelled buffer
             // operations.
             // We can thus ignore it, it is very unlikely to lead to true buffer issues.
@@ -372,3 +384,4 @@ export default function RepresentationStream(_a, callbacks, parentCancelSignal)
         callbacks.error(err);
     }
 }
+exports.default = RepresentationStream;

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

@@ -7,7 +7,7 @@ import { IContentProtection } from "../../decrypt";
 import { IPrioritizedSegmentFetcher } from "../../fetchers";
 import { IBufferType, SegmentBuffer } from "../../segment_buffers";
 /** Callbacks called by the `RepresentationStream` on various events. */
-export interface IRepresentationStreamCallbacks<TSegmentDataType> {
+export interface IRepresentationStreamCallbacks {
     /**
      * Called to announce the current status regarding the buffer for its
      * associated Period and type (e.g. "audio", "video", "text" etc.).
@@ -17,7 +17,7 @@ export interface IRepresentationStreamCallbacks<TSegmentDataType> {
      */
     streamStatusUpdate(payload: IStreamStatusPayload): void;
     /** Called after a new segment has been succesfully added to the SegmentBuffer */
-    addedSegment(payload: IStreamEventAddedSegmentPayload<TSegmentDataType>): void;
+    addedSegment(payload: IStreamEventAddedSegmentPayload): void;
     /** Called when a segment with protection information has been encountered. */
     encryptionDataEncountered(payload: IContentProtection[]): void;
     /**
@@ -112,7 +112,7 @@ export interface IStreamStatusPayload {
     position: number;
 }
 /** Payload for the `addedSegment` callback. */
-export interface IStreamEventAddedSegmentPayload<T> {
+export interface IStreamEventAddedSegmentPayload {
     /** Context about the content that has been added. */
     content: {
         period: Period;
@@ -123,7 +123,6 @@ export interface IStreamEventAddedSegmentPayload<T> {
     segment: ISegment;
     /** TimeRanges of the concerned SegmentBuffer after the segment was pushed. */
     buffered: TimeRanges;
-    segmentData: T;
 }
 /** Structure describing an "inband" event, as found in a media segment. */
 export interface IInbandEvent {

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

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