rx-player 3.28.0 → 3.28.1-dev.2022083000

package/src/parsers/manifest/smooth/create_parser.ts

@@ -562,9 +562,9 @@ function createSmoothStreamingParser(
         const firstVideoRepresentation = firstVideoAdaptation.representations[0];
         if (firstVideoRepresentation !== undefined) {
           const firstVideoTimeReference =
-            firstVideoRepresentation.index.getFirstPosition();
+            firstVideoRepresentation.index.getFirstAvailablePosition();
           const lastVideoTimeReference =
-            firstVideoRepresentation.index.getLastPosition();
+            firstVideoRepresentation.index.getLastAvailablePosition();
 
           if (firstVideoTimeReference != null) {
             firstTimeReferences.push(firstVideoTimeReference);
@@ -580,9 +580,9 @@ function createSmoothStreamingParser(
         const firstAudioRepresentation = firstAudioAdaptation.representations[0];
         if (firstAudioRepresentation !== undefined) {
           const firstAudioTimeReference =
-            firstAudioRepresentation.index.getFirstPosition();
+            firstAudioRepresentation.index.getFirstAvailablePosition();
           const lastAudioTimeReference =
-            firstAudioRepresentation.index.getLastPosition();
+            firstAudioRepresentation.index.getLastAvailablePosition();
 
           if (firstAudioTimeReference != null) {
             firstTimeReferences.push(firstAudioTimeReference);

package/src/parsers/manifest/smooth/representation_index.ts

@@ -21,6 +21,7 @@ import {
   ISegment,
 } from "../../../manifest";
 import { IPlayerError } from "../../../public_types";
+import assert from "../../../utils/assert";
 import clearTimelineFromPosition from "../utils/clear_timeline_from_position";
 import {
   checkDiscontinuity,
@@ -318,7 +319,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[] {
@@ -427,11 +428,9 @@ export default class SmoothRepresentationIndex implements IRepresentationIndex {
 
   /**
    * Returns first position available in the index.
-   *
-   * @param {Object} index
    * @returns {Number|null}
    */
-  getFirstPosition() : number|null {
+  getFirstAvailablePosition() : number|null {
     this._refreshTimeline();
     const index = this._index;
     if (index.timeline.length === 0) {
@@ -442,10 +441,9 @@ export default class SmoothRepresentationIndex implements IRepresentationIndex {
 
   /**
    * Returns last position available in the index.
-   * @param {Object} index
    * @returns {Number}
    */
-  getLastPosition() : number|undefined {
+  getLastAvailablePosition() : number|undefined {
     this._refreshTimeline();
     const index = this._index;
 
@@ -470,6 +468,42 @@ export default class SmoothRepresentationIndex implements IRepresentationIndex {
     return undefined;
   }
 
+  /**
+   * Returns the absolute end in seconds this RepresentationIndex can reach once
+   * all segments are available.
+   * @returns {number|null|undefined}
+   */
+  getEnd() : number | null | undefined {
+    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}
+   */
+  awaitSegmentBetween(start: number, end: number): boolean | undefined {
+    assert(start <= end);
+    if (this.isFinished()) {
+      return false;
+    }
+    const lastAvailablePosition = this.getLastAvailablePosition();
+    if (lastAvailablePosition !== undefined && end < lastAvailablePosition) {
+      return false;
+    }
+    return end > (this.getFirstAvailablePosition() ?? 0) ? undefined :
+                                                           false;
+  }
+
   /**
    * Checks if `timeSec` is in a discontinuity.
    * That is, if there's no segment available for the `timeSec` position.
@@ -484,15 +518,6 @@ export default class SmoothRepresentationIndex implements IRepresentationIndex {
     return checkDiscontinuity(this._index, timeSec, undefined);
   }
 
-  /**
-   * Returns `true` as Smooth segments should always be generated in
-   * chronological order.
-   * @returns {boolean}
-   */
-  areSegmentsChronologicallyGenerated() : true {
-    return true;
-  }
-
   /**
    * Returns `true` if a Segment returned by this index is still considered
    * available.

package/src/parsers/manifest/utils/__tests__/get_first_time_from_adaptations.test.ts

@@ -24,10 +24,11 @@ function generateRepresentationIndex(
     getInitSegment() { return null; },
     getSegments() { return []; },
     shouldRefresh() { return false; },
-    getFirstPosition() : number|undefined|null { return firstPosition; },
-    getLastPosition() : undefined { return ; },
+    getFirstAvailablePosition() : number|undefined|null { return firstPosition; },
+    getLastAvailablePosition() : undefined { return ; },
+    getEnd() : undefined { return ; },
+    awaitSegmentBetween() : undefined { return ; },
     checkDiscontinuity() : number | null { return null; },
-    areSegmentsChronologicallyGenerated() { return true; },
     isSegmentStillAvailable() : undefined { return ; },
     isFinished() { return false; },
     canBeOutOfSyncError() : true { return true; },

package/src/parsers/manifest/utils/__tests__/get_last_time_from_adaptation.test.ts

@@ -24,10 +24,11 @@ function generateRepresentationIndex(
     getInitSegment() { return null; },
     getSegments() { return []; },
     shouldRefresh() { return false; },
-    getFirstPosition() : undefined { return ; },
-    getLastPosition() : number|undefined|null { return lastPosition; },
+    getFirstAvailablePosition() : undefined { return ; },
+    getLastAvailablePosition() : number | undefined | null { return lastPosition; },
+    getEnd() : undefined { return ; },
+    awaitSegmentBetween() : undefined { return ; },
     checkDiscontinuity() : number | null { return null; },
-    areSegmentsChronologicallyGenerated() { return true; },
     isSegmentStillAvailable() : undefined { return ; },
     isFinished() { return false; },
     isInitialized() : true { return true; },

package/src/parsers/manifest/utils/get_first_time_from_adaptation.ts

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

package/src/parsers/manifest/utils/get_last_time_from_adaptation.ts

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

package/src/transports/metaplaylist/pipelines.ts

@@ -55,7 +55,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 : ISegment) : { manifest : Manifest;
@@ -198,7 +197,6 @@ export default function(options : ITransportOptions): ITransportPipelines {
 
   /**
    * @param {number} contentOffset
-   * @param {number} scaledContentOffset
    * @param {number|undefined} contentEnd
    * @param {Object} segmentResponse
    * @returns {Object}

package/src/transports/smooth/segment_loader.ts

@@ -38,7 +38,7 @@ 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/src/transports/types.ts

@@ -207,7 +207,7 @@ export interface ISegmentPipeline<
 
 /**
  * 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/src/utils/__tests__/initialization_segment_cache.test.ts

@@ -46,6 +46,7 @@ const initSegment1 = {
   timescale: 1 as const,
   mediaURLs: ["http://www.example.com/some.URLinit1"],
   complete: true,
+  privateInfos: {},
 };
 
 const initSegment2 = {
@@ -57,6 +58,7 @@ const initSegment2 = {
   timescale: 1 as const,
   mediaURLs: ["http://www.example.com/some.URLinit2"],
   complete: true,
+  privateInfos: {},
 };
 
 const initSegment3 = {
@@ -68,6 +70,7 @@ const initSegment3 = {
   timescale: 1 as const,
   mediaURLs: ["http://www.example.com/some.URLinit3"],
   complete: true,
+  privateInfos: {},
 };
 
 const segment1 = {
@@ -79,6 +82,7 @@ const segment1 = {
   timescale: 1 as const,
   mediaURLs: ["http://www.example.com/some.URL2"],
   complete: true,
+  privateInfos: {},
 };
 
 const segment2 = {
@@ -90,6 +94,7 @@ const segment2 = {
   timescale: 1 as const,
   mediaURLs: ["http://www.example.com/some.URL2"],
   complete: true,
+  privateInfos: {},
 };
 
 const segment3 = {
@@ -101,6 +106,7 @@ const segment3 = {
   timescale: 1 as const,
   mediaURLs: ["http://www.example.com/some.URL3"],
   complete: true,
+  privateInfos: {},
 };
 
 const segment4 = {
@@ -112,6 +118,7 @@ const segment4 = {
   timescale: 1 as const,
   mediaURLs: ["http://www.example.com/some.URL4"],
   complete: true,
+  privateInfos: {},
 };
 
 const data1 = new Uint8Array([0]);

package/src/utils/deep_merge.ts

@@ -24,7 +24,9 @@ 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 {
   if (sources.length === 0) {
     return target;
   }
@@ -32,10 +34,11 @@ export default function deepMerge<T>(target: T, ...sources: ISourcesArgument<T>)
   if (isObject(target) && isObject(source)) {
     for (const key in source) {
       if (isObject(source[key])) {
-        if (target[key] === undefined) {
-          objectAssign(target, { [key]: {} });
+        let newTarget = target[key] as Record<string | number | symbol, unknown>;
+        if (newTarget === undefined) {
+          newTarget = {};
+          (target[key] as Record<string | number | symbol, unknown>) = newTarget;
         }
-        const newTarget = target[key];
         deepMerge(newTarget, source[key] as IDeepPartial<typeof newTarget>);
       } else {
         objectAssign(target, { [key]: source[key] });

package/src/utils/task_canceller.ts

@@ -308,9 +308,6 @@ export class CancellationError extends Error {
   public readonly name : "CancellationError";
   public readonly message : string;
 
-  /**
-   * @param {string} message
-   */
   constructor() {
     super();
     // @see https://stackoverflow.com/questions/41102060/typescript-extending-error-class