rx-player 3.28.0-dev.2022063000 → 3.28.1-dev.2022083000

package/dist/_esm5.processed/parsers/manifest/local/representation_index.js

@@ -24,10 +24,9 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
 };
 import log from "../../../log";
 var LocalRepresentationIndex = /** @class */ (function () {
-    function LocalRepresentationIndex(index, representationId, isFinished) {
+    function LocalRepresentationIndex(index, representationId) {
         this._index = index;
         this._representationId = representationId;
-        this._isFinished = isFinished;
     }
     /**
      * @returns {Object}
@@ -90,7 +89,7 @@ var LocalRepresentationIndex = /** @class */ (function () {
     /**
      * @returns {Number|undefined}
      */
-    LocalRepresentationIndex.prototype.getFirstPosition = function () {
+    LocalRepresentationIndex.prototype.getFirstAvailablePosition = function () {
         if (this._index.segments.length === 0) {
             return undefined;
         }
@@ -100,12 +99,56 @@ var LocalRepresentationIndex = /** @class */ (function () {
     /**
      * @returns {Number|undefined}
      */
-    LocalRepresentationIndex.prototype.getLastPosition = function () {
+    LocalRepresentationIndex.prototype.getLastAvailablePosition = function () {
         if (this._index.segments.length === 0) {
             return undefined;
         }
         var lastSegment = this._index.segments[this._index.segments.length - 1];
-        return lastSegment.time;
+        return lastSegment.time + lastSegment.duration;
+    };
+    /**
+     * Returns the expected ending position of this RepresentationIndex.
+     * `undefined` if unknown.
+     * @returns {number|undefined}
+     */
+    LocalRepresentationIndex.prototype.getEnd = function () {
+        if (this._index.isFinished) {
+            return this.getLastAvailablePosition();
+        }
+        var _a = this._index, incomingRanges = _a.incomingRanges, segments = _a.segments;
+        if (incomingRanges === undefined || incomingRanges.length === 0) {
+            // If incomingRanges is empty but not finished... It's ambiguous.
+            return undefined;
+        }
+        var lastIncomingRange = incomingRanges[incomingRanges.length - 1];
+        var futureEnd = lastIncomingRange.end;
+        if (segments.length === 0) {
+            return futureEnd;
+        }
+        var lastSegment = this._index.segments[this._index.segments.length - 1];
+        return Math.max(lastSegment.time + lastSegment.duration, futureEnd);
+    };
+    /**
+     * Returns:
+     *   - `true` if in the given time interval, at least one new segment is
+     *     expected to be available in the future.
+     *   - `false` either if all segments in that time interval are already
+     *     available for download or if none will ever be available for it.
+     *   - `undefined` when it is not possible to tell.
+     * @param {number} start
+     * @param {number} end
+     * @returns {boolean|undefined}
+     */
+    LocalRepresentationIndex.prototype.awaitSegmentBetween = function (start, end) {
+        if (this.isFinished()) {
+            return false;
+        }
+        if (this._index.incomingRanges === undefined) {
+            return undefined;
+        }
+        return this._index.incomingRanges.some(function (range) {
+            return range.start < end && range.end > start;
+        });
     };
     /**
      * @returns {Boolean}
@@ -120,7 +163,7 @@ var LocalRepresentationIndex = /** @class */ (function () {
         return true;
     };
     LocalRepresentationIndex.prototype.isFinished = function () {
-        return this._isFinished;
+        return this._index.isFinished;
     };
     /**
      * @returns {Boolean}
@@ -134,12 +177,6 @@ var LocalRepresentationIndex = /** @class */ (function () {
     LocalRepresentationIndex.prototype.checkDiscontinuity = function () {
         return null;
     };
-    /**
-     * @returns {boolean}
-     */
-    LocalRepresentationIndex.prototype.areSegmentsChronologicallyGenerated = function () {
-        return false;
-    };
     /**
      * @returns {Boolean}
      */
@@ -147,14 +184,12 @@ var LocalRepresentationIndex = /** @class */ (function () {
         return true;
     };
     LocalRepresentationIndex.prototype._replace = function (newIndex) {
-        this._isFinished = newIndex._isFinished;
         this._index.segments = newIndex._index.segments;
         this._index.loadSegment = newIndex._index.loadSegment;
         this._index.loadInitSegment = newIndex._index.loadInitSegment;
     };
     LocalRepresentationIndex.prototype._update = function (newIndex) {
         var _this = this;
-        this._isFinished = newIndex._isFinished;
         var newSegments = newIndex._index.segments;
         if (newSegments.length <= 0) {
             return;

package/dist/_esm5.processed/parsers/manifest/local/types.d.ts

@@ -148,6 +148,8 @@ export interface ILocalIndexSegment {
 }
 /** "Index" of a `ILocalRepresentation`. Allow to declare available segments. */
 export interface ILocalIndex {
+    /** Every segments in that `ILocalIndex` has been downloaded. */
+    isFinished: boolean;
     /** Callback used to retrieve the initialization segment of a `ILocalRepresentation`. */
     loadInitSegment: ILocalManifestInitSegmentLoader;
     /** Callback used to retrieve a media segment of a `ILocalRepresentation`. */
@@ -157,6 +159,14 @@ export interface ILocalIndex {
      * Doesn't include the initialization segment.
      */
     segments: ILocalIndexSegment[];
+    /**
+     * List of not yet available time ranges, that should become available once
+     * the content is fully loaded.
+     */
+    incomingRanges?: Array<{
+        start: number;
+        end: number;
+    }>;
 }
 /** A quality for a given "local" Manifest track (`ILocalAdaptation`). */
 export interface ILocalRepresentation {
@@ -235,6 +245,12 @@ export interface ILocalManifest {
      *            `start` and `duration` from a ILocalPeriod and `time` and
      *            `duration` from a `ILocalIndexSegment` are now in seconds
      *            instead of milliseconds.
+     *
+     *   - "0.3": optional `futureSegments` has been added to `ILocalIndex`
+     *            `duration` has been removed.
+     *
+     *            A mandatory `isFinished` boolean should now be set on a
+     *            `ILocalIndex`.
      */
     version: string;
     /**

package/dist/_esm5.processed/parsers/manifest/metaplaylist/representation_index.d.ts

@@ -73,13 +73,31 @@ export default class MetaRepresentationIndex implements IRepresentationIndex {
      * `undefined` if we do not know this value.
      * @return {Number|undefined}
      */
-    getFirstPosition(): number | undefined;
+    getFirstAvailablePosition(): number | undefined;
     /**
      * Returns last possible position the last segment plays at, in seconds.
      * `undefined` if we do not know this value.
      * @return {Number|undefined}
      */
-    getLastPosition(): number | undefined;
+    getLastAvailablePosition(): number | undefined;
+    /**
+     * Returns the absolute end in seconds this RepresentationIndex can reach once
+     * all segments are available.
+     * @returns {number|null|undefined}
+     */
+    getEnd(): number | undefined | null;
+    /**
+     * Returns:
+     *   - `true` if in the given time interval, at least one new segment is
+     *     expected to be available in the future.
+     *   - `false` either if all segments in that time interval are already
+     *     available for download or if none will ever be available for it.
+     *   - `undefined` when it is not possible to tell.
+     * @param {number} start
+     * @param {number} end
+     * @returns {boolean|undefined}
+     */
+    awaitSegmentBetween(start: number, end: number): boolean | undefined;
     /**
      * Returns `false` if that segment is not currently available in the Manifest
      * (e.g. it corresponds to a segment which is before the current buffer
@@ -100,10 +118,6 @@ export default class MetaRepresentationIndex implements IRepresentationIndex {
      * @returns {Number | null}
      */
     checkDiscontinuity(time: number): number | null;
-    /**
-     * @returns {Boolean}
-     */
-    areSegmentsChronologicallyGenerated(): boolean;
     /**
      * @returns {Boolean}
      */

package/dist/_esm5.processed/parsers/manifest/metaplaylist/representation_index.js

@@ -85,8 +85,8 @@ var MetaRepresentationIndex = /** @class */ (function () {
      * `undefined` if we do not know this value.
      * @return {Number|undefined}
      */
-    MetaRepresentationIndex.prototype.getFirstPosition = function () {
-        var wrappedFirstPosition = this._wrappedIndex.getFirstPosition();
+    MetaRepresentationIndex.prototype.getFirstAvailablePosition = function () {
+        var wrappedFirstPosition = this._wrappedIndex.getFirstAvailablePosition();
         return wrappedFirstPosition != null ? wrappedFirstPosition + this._timeOffset :
             undefined;
     };
@@ -95,11 +95,35 @@ var MetaRepresentationIndex = /** @class */ (function () {
      * `undefined` if we do not know this value.
      * @return {Number|undefined}
      */
-    MetaRepresentationIndex.prototype.getLastPosition = function () {
-        var wrappedLastPosition = this._wrappedIndex.getLastPosition();
+    MetaRepresentationIndex.prototype.getLastAvailablePosition = function () {
+        var wrappedLastPosition = this._wrappedIndex.getLastAvailablePosition();
         return wrappedLastPosition != null ? wrappedLastPosition + this._timeOffset :
             undefined;
     };
+    /**
+     * Returns the absolute end in seconds this RepresentationIndex can reach once
+     * all segments are available.
+     * @returns {number|null|undefined}
+     */
+    MetaRepresentationIndex.prototype.getEnd = function () {
+        var wrappedEnd = this._wrappedIndex.getEnd();
+        return wrappedEnd != null ? wrappedEnd + this._timeOffset :
+            undefined;
+    };
+    /**
+     * Returns:
+     *   - `true` if in the given time interval, at least one new segment is
+     *     expected to be available in the future.
+     *   - `false` either if all segments in that time interval are already
+     *     available for download or if none will ever be available for it.
+     *   - `undefined` when it is not possible to tell.
+     * @param {number} start
+     * @param {number} end
+     * @returns {boolean|undefined}
+     */
+    MetaRepresentationIndex.prototype.awaitSegmentBetween = function (start, end) {
+        return this._wrappedIndex.awaitSegmentBetween(start - this._timeOffset, end - this._timeOffset);
+    };
     /**
      * Returns `false` if that segment is not currently available in the Manifest
      * (e.g. it corresponds to a segment which is before the current buffer
@@ -136,12 +160,6 @@ var MetaRepresentationIndex = /** @class */ (function () {
     MetaRepresentationIndex.prototype.checkDiscontinuity = function (time) {
         return this._wrappedIndex.checkDiscontinuity(time - this._timeOffset);
     };
-    /**
-     * @returns {Boolean}
-     */
-    MetaRepresentationIndex.prototype.areSegmentsChronologicallyGenerated = function () {
-        return this._wrappedIndex.areSegmentsChronologicallyGenerated();
-    };
     /**
      * @returns {Boolean}
      */

package/dist/_esm5.processed/parsers/manifest/smooth/create_parser.js

@@ -390,8 +390,8 @@ function createSmoothStreamingParser(parserOptions) {
             if (firstVideoAdaptation !== undefined) {
                 var firstVideoRepresentation = firstVideoAdaptation.representations[0];
                 if (firstVideoRepresentation !== undefined) {
-                    var firstVideoTimeReference = firstVideoRepresentation.index.getFirstPosition();
-                    var lastVideoTimeReference = firstVideoRepresentation.index.getLastPosition();
+                    var firstVideoTimeReference = firstVideoRepresentation.index.getFirstAvailablePosition();
+                    var lastVideoTimeReference = firstVideoRepresentation.index.getLastAvailablePosition();
                     if (firstVideoTimeReference != null) {
                         firstTimeReferences.push(firstVideoTimeReference);
                     }
@@ -403,8 +403,8 @@ function createSmoothStreamingParser(parserOptions) {
             if (firstAudioAdaptation !== undefined) {
                 var firstAudioRepresentation = firstAudioAdaptation.representations[0];
                 if (firstAudioRepresentation !== undefined) {
-                    var firstAudioTimeReference = firstAudioRepresentation.index.getFirstPosition();
-                    var lastAudioTimeReference = firstAudioRepresentation.index.getLastPosition();
+                    var firstAudioTimeReference = firstAudioRepresentation.index.getFirstAvailablePosition();
+                    var lastAudioTimeReference = firstAudioRepresentation.index.getLastAvailablePosition();
                     if (firstAudioTimeReference != null) {
                         firstTimeReferences.push(firstAudioTimeReference);
                     }

package/dist/_esm5.processed/parsers/manifest/smooth/representation_index.d.ts

@@ -172,7 +172,7 @@ export default class SmoothRepresentationIndex implements IRepresentationIndex {
      * Generate a list of Segments for a particular period of time.
      *
      * @param {Number} from
-     * @param {Number} duration
+     * @param {Number} dur
      * @returns {Array.<Object>}
      */
     getSegments(from: number, dur: number): ISegment[];
@@ -186,17 +186,32 @@ export default class SmoothRepresentationIndex implements IRepresentationIndex {
     shouldRefresh(up: number, to: number): boolean;
     /**
      * Returns first position available in the index.
-     *
-     * @param {Object} index
      * @returns {Number|null}
      */
-    getFirstPosition(): number | null;
+    getFirstAvailablePosition(): number | null;
     /**
      * Returns last position available in the index.
-     * @param {Object} index
      * @returns {Number}
      */
-    getLastPosition(): number | undefined;
+    getLastAvailablePosition(): number | undefined;
+    /**
+     * Returns the absolute end in seconds this RepresentationIndex can reach once
+     * all segments are available.
+     * @returns {number|null|undefined}
+     */
+    getEnd(): number | null | undefined;
+    /**
+     * Returns:
+     *   - `true` if in the given time interval, at least one new segment is
+     *     expected to be available in the future.
+     *   - `false` either if all segments in that time interval are already
+     *     available for download or if none will ever be available for it.
+     *   - `undefined` when it is not possible to tell.
+     * @param {number} start
+     * @param {number} end
+     * @returns {boolean|undefined}
+     */
+    awaitSegmentBetween(start: number, end: number): boolean | undefined;
     /**
      * Checks if `timeSec` is in a discontinuity.
      * That is, if there's no segment available for the `timeSec` position.
@@ -207,12 +222,6 @@ export default class SmoothRepresentationIndex implements IRepresentationIndex {
      * position for which a segment is available in seconds.
      */
     checkDiscontinuity(timeSec: number): number | null;
-    /**
-     * Returns `true` as Smooth segments should always be generated in
-     * chronological order.
-     * @returns {boolean}
-     */
-    areSegmentsChronologicallyGenerated(): true;
     /**
      * Returns `true` if a Segment returned by this index is still considered
      * available.

package/dist/_esm5.processed/parsers/manifest/smooth/representation_index.js

@@ -15,6 +15,7 @@
  */
 import { NetworkError } from "../../../errors";
 import log from "../../../log";
+import assert from "../../../utils/assert";
 import clearTimelineFromPosition from "../utils/clear_timeline_from_position";
 import { checkDiscontinuity, getIndexSegmentEnd, } from "../utils/index_helpers";
 import isSegmentStillAvailable from "../utils/is_segment_still_available";
@@ -128,7 +129,7 @@ var SmoothRepresentationIndex = /** @class */ (function () {
      * Generate a list of Segments for a particular period of time.
      *
      * @param {Number} from
-     * @param {Number} duration
+     * @param {Number} dur
      * @returns {Array.<Object>}
      */
     SmoothRepresentationIndex.prototype.getSegments = function (from, dur) {
@@ -214,11 +215,9 @@ var SmoothRepresentationIndex = /** @class */ (function () {
     };
     /**
      * Returns first position available in the index.
-     *
-     * @param {Object} index
      * @returns {Number|null}
      */
-    SmoothRepresentationIndex.prototype.getFirstPosition = function () {
+    SmoothRepresentationIndex.prototype.getFirstAvailablePosition = function () {
         this._refreshTimeline();
         var index = this._index;
         if (index.timeline.length === 0) {
@@ -228,10 +227,9 @@ var SmoothRepresentationIndex = /** @class */ (function () {
     };
     /**
      * Returns last position available in the index.
-     * @param {Object} index
      * @returns {Number}
      */
-    SmoothRepresentationIndex.prototype.getLastPosition = function () {
+    SmoothRepresentationIndex.prototype.getLastAvailablePosition = function () {
         this._refreshTimeline();
         var index = this._index;
         if (this._scaledLiveGap == null) {
@@ -253,6 +251,41 @@ var SmoothRepresentationIndex = /** @class */ (function () {
         }
         return undefined;
     };
+    /**
+     * Returns the absolute end in seconds this RepresentationIndex can reach once
+     * all segments are available.
+     * @returns {number|null|undefined}
+     */
+    SmoothRepresentationIndex.prototype.getEnd = function () {
+        if (!this._isLive) {
+            return this.getLastAvailablePosition();
+        }
+        return undefined;
+    };
+    /**
+     * Returns:
+     *   - `true` if in the given time interval, at least one new segment is
+     *     expected to be available in the future.
+     *   - `false` either if all segments in that time interval are already
+     *     available for download or if none will ever be available for it.
+     *   - `undefined` when it is not possible to tell.
+     * @param {number} start
+     * @param {number} end
+     * @returns {boolean|undefined}
+     */
+    SmoothRepresentationIndex.prototype.awaitSegmentBetween = function (start, end) {
+        var _a;
+        assert(start <= end);
+        if (this.isFinished()) {
+            return false;
+        }
+        var lastAvailablePosition = this.getLastAvailablePosition();
+        if (lastAvailablePosition !== undefined && end < lastAvailablePosition) {
+            return false;
+        }
+        return end > ((_a = this.getFirstAvailablePosition()) !== null && _a !== void 0 ? _a : 0) ? undefined :
+            false;
+    };
     /**
      * Checks if `timeSec` is in a discontinuity.
      * That is, if there's no segment available for the `timeSec` position.
@@ -266,14 +299,6 @@ var SmoothRepresentationIndex = /** @class */ (function () {
         this._refreshTimeline();
         return checkDiscontinuity(this._index, timeSec, undefined);
     };
-    /**
-     * Returns `true` as Smooth segments should always be generated in
-     * chronological order.
-     * @returns {boolean}
-     */
-    SmoothRepresentationIndex.prototype.areSegmentsChronologicallyGenerated = function () {
-        return true;
-    };
     /**
      * Returns `true` if a Segment returned by this index is still considered
      * available.

package/dist/_esm5.processed/parsers/manifest/utils/get_first_time_from_adaptation.js

@@ -27,7 +27,7 @@ export default function getFirstPositionFromAdaptation(adaptation) {
     var representations = adaptation.representations;
     var max = null;
     for (var i = 0; i < representations.length; i++) {
-        var firstPosition = representations[i].index.getFirstPosition();
+        var firstPosition = representations[i].index.getFirstAvailablePosition();
         if (firstPosition === undefined) { // we cannot tell
             return undefined;
         }

package/dist/_esm5.processed/parsers/manifest/utils/get_last_time_from_adaptation.js

@@ -29,7 +29,7 @@ export default function getLastPositionFromAdaptation(adaptation) {
     var representations = adaptation.representations;
     var min = null;
     for (var i = 0; i < representations.length; i++) {
-        var lastPosition = representations[i].index.getLastPosition();
+        var lastPosition = representations[i].index.getLastAvailablePosition();
         if (lastPosition === undefined) { // we cannot tell
             return undefined;
         }

package/dist/_esm5.processed/transports/metaplaylist/pipelines.js

@@ -33,7 +33,6 @@ import generateManifestLoader from "./manifest_loader";
 /**
  * Get base - real - content from an offseted metaplaylist content.
  * @param {Object} segment
- * @param {number} offset
  * @returns {Object}
  */
 function getOriginalContent(segment) {
@@ -128,7 +127,6 @@ export default function (options) {
     }
     /**
      * @param {number} contentOffset
-     * @param {number} scaledContentOffset
      * @param {number|undefined} contentEnd
      * @param {Object} segmentResponse
      * @returns {Object}

package/dist/_esm5.processed/transports/smooth/segment_loader.js

@@ -33,7 +33,7 @@ import { createAudioInitSegment, createVideoInitSegment, } from "./isobmff";
 import { isMP4EmbeddedTrack } from "./utils";
 /**
  * Segment loader triggered if there was no custom-defined one in the API.
- * @param {string} uri
+ * @param {string} url
  * @param {Object} content
  * @param {Object} callbacks
  * @param {Object} cancelSignal

package/dist/_esm5.processed/transports/types.d.ts

@@ -161,7 +161,7 @@ export interface ISegmentPipeline<TLoadedFormat, TParsedSegmentDataFormat> {
 }
 /**
  * Segment loader function, allowing to load a segment of any type.
- * @param {stop|null} url - URL at which the segment should be downloaded.
+ * @param {string|null} url - URL at which the segment should be downloaded.
  * `null` if we do not have an URL (in which case the segment should be loaded
  * through other means, such as information taken from the segment's content).
  * @param {Object} content - Content linked to the wanted segment.

package/dist/_esm5.processed/utils/deep_merge.d.ts

@@ -8,5 +8,5 @@ declare type ISourcesArgument<T> = Array<IDeepPartial<T> | unknown>;
  * @param sources
  * @returns output : merged object
  */
-export default function deepMerge<T>(target: T, ...sources: ISourcesArgument<T>): T;
+export default function deepMerge<T extends Record<string | number | symbol, unknown>>(target: T, ...sources: ISourcesArgument<T>): T;
 export {};

package/dist/_esm5.processed/utils/deep_merge.js

@@ -26,7 +26,7 @@ function isObject(item) {
  * @returns output : merged object
  */
 export default function deepMerge(target) {
-    var _a, _b;
+    var _a;
     var sources = [];
     for (var _i = 1; _i < arguments.length; _i++) {
         sources[_i - 1] = arguments[_i];
@@ -38,14 +38,15 @@ export default function deepMerge(target) {
     if (isObject(target) && isObject(source)) {
         for (var key in source) {
             if (isObject(source[key])) {
-                if (target[key] === undefined) {
-                    objectAssign(target, (_a = {}, _a[key] = {}, _a));
-                }
                 var newTarget = target[key];
+                if (newTarget === undefined) {
+                    newTarget = {};
+                    target[key] = newTarget;
+                }
                 deepMerge(newTarget, source[key]);
             }
             else {
-                objectAssign(target, (_b = {}, _b[key] = source[key], _b));
+                objectAssign(target, (_a = {}, _a[key] = source[key], _a));
             }
         }
     }

package/dist/_esm5.processed/utils/task_canceller.d.ts

@@ -241,8 +241,5 @@ export declare type ICancellationListener = (error: CancellationError) => void;
 export declare class CancellationError extends Error {
     readonly name: "CancellationError";
     readonly message: string;
-    /**
-     * @param {string} message
-     */
     constructor();
 }

package/dist/_esm5.processed/utils/task_canceller.js

@@ -264,9 +264,6 @@ export { CancellationSignal };
  */
 var CancellationError = /** @class */ (function (_super) {
     __extends(CancellationError, _super);
-    /**
-     * @param {string} message
-     */
     function CancellationError() {
         var _this = _super.call(this) || this;
         // @see https://stackoverflow.com/questions/41102060/typescript-extending-error-class