rx-player 3.25.2 → 3.26.3-dev.2022021400

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

@@ -178,12 +178,12 @@ export interface ISmoothRepresentationIndexContextInformation {
 
 /** Information allowing to generate a Smooth initialization segment. */
 interface ISmoothInitSegmentPrivateInfos {
-  bitsPerSample? : number;
-  channels? : number;
-  codecPrivateData? : string;
-  packetSize? : number;
-  samplingRate? : number;
-  protection? : { keyId : Uint8Array };
+  bitsPerSample? : number | undefined;
+  channels? : number | undefined;
+  codecPrivateData? : string | undefined;
+  packetSize? : number | undefined;
+  samplingRate? : number | undefined;
+  protection? : { keyId : Uint8Array } | undefined;
 }
 
 /**
@@ -198,13 +198,13 @@ export default class SmoothRepresentationIndex implements IRepresentationIndex {
    * Information needed to generate an initialization segment.
    * Taken from the Manifest.
    */
-  private _initSegmentInfos : { codecPrivateData? : string;
-                                bitsPerSample? : number;
-                                channels? : number;
-                                packetSize? : number;
-                                samplingRate? : number;
+  private _initSegmentInfos : { codecPrivateData? : string | undefined;
+                                bitsPerSample? : number | undefined;
+                                channels? : number | undefined;
+                                packetSize? : number | undefined;
+                                samplingRate? : number | undefined;
                                 timescale : number;
-                                protection? : { keyId : Uint8Array }; };
+                                protection? : { keyId : Uint8Array } | undefined; };
 
   /**
    * if `true`, this class will return segments even if we're not sure they had
@@ -225,13 +225,13 @@ export default class SmoothRepresentationIndex implements IRepresentationIndex {
    * Useful to know if a segment present in the timeline has actually been
    * generated on the server-side
    */
-  private _scaledLiveGap? : number;
+  private _scaledLiveGap : number | undefined;
 
   /**
    * Defines the end of the latest available segment when this index was known to
    * be valid, in the index's timescale.
    */
-  private _initialScaledLastPosition? : number;
+  private _initialScaledLastPosition : number | undefined;
 
   /**
    * Defines the earliest time when this index was known to be valid (that is, when
@@ -312,7 +312,8 @@ export default class SmoothRepresentationIndex implements IRepresentationIndex {
              time: 0,
              end: 0,
              duration: 0,
-             timescale: 1 };
+             timescale: 1,
+             complete: true };
   }
 
   /**
@@ -362,6 +363,7 @@ export default class SmoothRepresentationIndex implements IRepresentationIndex {
                           timescale: 1 as const,
                           number,
                           mediaURLs: [replaceSegmentSmoothTokens(media, time)],
+                          complete: true,
                           privateInfos: { smoothMediaSegment: { time,
                                                                 duration } } };
         segments.push(segment);

package/src/parsers/manifest/types.ts

@@ -18,8 +18,8 @@ import { IRepresentationIndex } from "../../manifest";
 import { IHDRInformation } from "../../manifest/types";
 
 export interface IManifestStreamEvent { start: number;
-                                        end?: number;
-                                        id?: string;
+                                        end?: number | undefined;
+                                        id?: string | undefined;
                                         data: IParsedStreamEventData; }
 
 export interface IParsedStreamEventData {
@@ -33,7 +33,7 @@ export interface IParsedStreamEventData {
 
 /** Describes information about an encryption Key ID of a given media. */
 export interface IContentProtectionKID { keyId : Uint8Array;
-                                         systemId?: string; }
+                                         systemId?: string | undefined; }
 
 /**
  * Encryption initialization data.
@@ -92,37 +92,37 @@ export interface IParsedRepresentation {
   id: string;
 
   /** Codec(s) associated with this Representation. */
-  codecs?: string;
+  codecs?: string | undefined;
   /**
    * Information about the encryption associated with this Representation.
    * Not set if unknown or if the content is not encrypted.
    */
-  contentProtections? : IContentProtections;
+  contentProtections? : IContentProtections | undefined;
   /**
    * Frame rate (images per seconds) associated with this Representation.
    * Not set if unknown or if it makes no sense (e.g. for subtitles).
    */
-  frameRate?: string;
+  frameRate?: string | undefined;
   /**
    * Height (top to bottom) in pixels this Representation has.
    * Not set if unknown or if it makes no sense (e.g. for audio).
    */
-  height?: number;
+  height?: number | undefined;
   /**
    * Defines the mime-type of the content.
    * This allows to deduce the media container but most of the time, the
    * `codecs` will also be needed to know how to decode that media.
    */
-  mimeType?: string;
+  mimeType?: string | undefined;
   /**
    * Width (left to right) in pixels this Representation has.
    * Not set if unknown or if it makes no sense (e.g. for audio).
    */
-  width?: number;
+  width?: number | undefined;
   /**
    * Information about the HDR characteristic of a content.
    */
-  hdrInfo?: IHDRInformation;
+  hdrInfo?: IHDRInformation | undefined;
 }
 
 /** Every possible types an Adaptation can have. */
@@ -155,34 +155,34 @@ export interface IParsedAdaptation {
    * Not set if unknown or if it makes no sense for the current track (e.g. for
    * a video track).
    */
-  audioDescription? : boolean;
+  audioDescription? : boolean | undefined;
   /**
    * Whether this Adaptation are closed captions for the hard of hearing.
    * Not set if unknown or if it makes no sense for the current track (e.g. for
    * a video track).
    */
-  closedCaption? : boolean;
+  closedCaption? : boolean | undefined;
   /**
    * If true this Adaptation is in a dub: it was recorded in another language
    * than the original(s) one(s).
    */
-  isDub? : boolean;
+  isDub? : boolean | undefined;
   /**
    * If true this Adaptation is in a sign interpreted: which is a variant of the
    * video with sign language.
    */
-  isSignInterpreted? : boolean;
+  isSignInterpreted? : boolean | undefined;
   /** Tells if the track is a trick mode track. */
-  isTrickModeTrack? : boolean;
+  isTrickModeTrack? : boolean | undefined;
   /**
    * Language the `Adaptation` is in.
    * Not set if unknown or if it makes no sense for the current track.
    */
-  language?: string;
+  language?: string | undefined;
   /**
    * TrickMode tracks attached to the adaptation.
    */
-  trickModeTracks?: IParsedAdaptation[];
+  trickModeTracks?: IParsedAdaptation[] | undefined;
 }
 
 /** Information on a given period of time in the Manifest */
@@ -205,18 +205,18 @@ export interface IParsedPeriod {
    * Duration of the Period (from the start to the end), in seconds.
    * `undefined` if the Period is the last one and is still being updated.
    */
-  duration? : number;
+  duration? : number | undefined;
   /**
    * Time at which the Period ends, in seconds.
    * `undefined` if the Period is the last one and is still
    * being updated.
    */
-  end? : number;
+  end? : number | undefined;
   /**
    * Array containing every stream event from period in manifest.
    * `undefined` if no parsed stream event in manifest.
    */
-  streamEvents?: IManifestStreamEvent[];
+  streamEvents?: IManifestStreamEvent[] | undefined;
 }
 
 /** Information on the whole content */
@@ -240,23 +240,23 @@ export interface IParsedManifest {
    * The wall-clock time when the manifest was generated and published at the
    * origin server
    */
-  publishTime?: number;
+  publishTime? : number | undefined;
   /** Underlying transport protocol: "smooth", "dash", "metaplaylist" etc. */
   transportType: string;
   /** Base time from which the segments are generated. */
-  availabilityStartTime? : number;
+  availabilityStartTime? : number | undefined;
   /**
    * Offset, in milliseconds, the client's clock (in terms of `performance.now`)
    * has relatively to the server's
    */
-  clockOffset?: number;
+  clockOffset? : number | undefined;
   /** If set, the Manifest needs to be updated when that Promise resolves. */
-  expired? : Promise<void>;
+  expired? : Promise<void> | undefined;
   /**
    * Duration of the validity of this Manifest from its download time.
    * After that time has elapsed, the Manifest should be refreshed.
    */
-  lifetime?: number;
+  lifetime? : number | undefined;
   /**
    * Data allowing to calculate the minimum and maximum seekable positions at
    * any given time.
@@ -266,7 +266,7 @@ export interface IParsedManifest {
      * The minimum time, in seconds, available in this Manifest.
      * `undefined` if that value is unknown.
      */
-    absoluteMinimumTime? : number;
+    absoluteMinimumTime? : number | undefined;
     /**
      * Some dynamic contents have the concept of a "window depth" (or "buffer
      * depth") which allows to set a minimum position for all reachable
@@ -311,8 +311,8 @@ export interface IParsedManifest {
    * Suggested delay from the last position the player should start from by
    * default.
    */
-  suggestedPresentationDelay? : number;
+  suggestedPresentationDelay? : number | undefined;
   /** URIs where the manifest can be refreshed by order of importance. */
-  uris?: string[];
+  uris? : string[] | undefined;
 }
 

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

@@ -26,7 +26,7 @@ import { IIndexSegment } from "../index_helpers";
 describe("Manifest Parsers utils - updateSegmentTimeline", () => {
   let logWarnSpy : jest.MockInstance<void, unknown[]> | undefined;
   let updateSegmentTimeline : ((a : IIndexSegment[],
-                                b : IIndexSegment[]) => void) | undefined;
+                                b : IIndexSegment[]) => boolean) | undefined;
   beforeEach(() => {
     jest.resetModules();
 
@@ -44,7 +44,7 @@ describe("Manifest Parsers utils - updateSegmentTimeline", () => {
     const oldTimeline : IIndexSegment[] = [];
     const newTimeline1 = [{ start: 0, duration: 1000, repeatCount: 10 }];
     const newTimeline2 : IIndexSegment[] = [];
-    updateSegmentTimeline?.(oldTimeline, newTimeline1);
+    expect(updateSegmentTimeline?.(oldTimeline, newTimeline1)).toEqual(true);
     expect(oldTimeline).toEqual(newTimeline1);
 
     oldTimeline.length = 0; // reset
@@ -57,7 +57,7 @@ describe("Manifest Parsers utils - updateSegmentTimeline", () => {
     const oldTimeline = [{ start: 0, duration: 1000, repeatCount: 10 }];
     const newTimeline : IIndexSegment[] = [];
     const oldTimelineCloned = oldTimeline.slice();
-    updateSegmentTimeline?.(oldTimeline, newTimeline);
+    expect(updateSegmentTimeline?.(oldTimeline, newTimeline)).toEqual(false);
     expect(oldTimeline).toEqual(oldTimelineCloned);
     expect(logWarnSpy).not.toHaveBeenCalled();
   });
@@ -66,7 +66,7 @@ describe("Manifest Parsers utils - updateSegmentTimeline", () => {
     const oldTimeline1 = [{ start: 0, duration: 1000, repeatCount: 10 }];
     const newTimeline1 = [{ start: 0, duration: 1000, repeatCount: 10 }];
     const oldTimeline1Cloned = oldTimeline1.slice();
-    updateSegmentTimeline?.(oldTimeline1, newTimeline1);
+    expect(updateSegmentTimeline?.(oldTimeline1, newTimeline1)).toEqual(false);
     expect(oldTimeline1).toEqual(oldTimeline1Cloned);
 
     const oldTimeline2 = [ { start: 0, duration: 1000, repeatCount: 10 },
@@ -76,7 +76,7 @@ describe("Manifest Parsers utils - updateSegmentTimeline", () => {
                            { start: 11000, duration: 1000, repeatCount: 0 },
                            { start: 12000, duration: 1000, repeatCount: 1 } ];
     const oldTimeline2Cloned = oldTimeline2.slice();
-    updateSegmentTimeline?.(oldTimeline2, newTimeline2);
+    expect(updateSegmentTimeline?.(oldTimeline2, newTimeline2)).toEqual(false);
     expect(oldTimeline2).toEqual(oldTimeline2Cloned);
     expect(logWarnSpy).not.toHaveBeenCalled();
   });
@@ -93,14 +93,19 @@ describe("Manifest Parsers utils - updateSegmentTimeline", () => {
 
     let err = null;
     try {
-      updateSegmentTimeline?.(oldTimeline1, newTimeline1);
+      expect(updateSegmentTimeline?.(oldTimeline1, newTimeline1)).not.toHaveReturned();
     } catch (e) {
       err = e;
     }
 
-    expect(err).not.toBeNull();
-    expect(err.type).toEqual("MEDIA_ERROR");
-    expect(err.code).toEqual("MANIFEST_UPDATE_ERROR");
+    expect(err).toBeInstanceOf(Error);
+
+    // Impossible check to shut-up TypeScript
+    if (!(err instanceof Error)) {
+      throw new Error("Impossible: already checked it was an Error instance");
+    }
+    expect((err as { type? : string }).type).toEqual("MEDIA_ERROR");
+    expect((err as { code? : string }).code).toEqual("MANIFEST_UPDATE_ERROR");
     expect(err.message)
       .toEqual("MediaError (MANIFEST_UPDATE_ERROR) Cannot perform " +
                "partial update: not enough data");
@@ -116,7 +121,7 @@ describe("Manifest Parsers utils - updateSegmentTimeline", () => {
                            { start: 25100, duration: 1000, repeatCount: 1 } ];
     const oldTimeline1Cloned = oldTimeline1.slice();
     const newTimeline1Cloned = newTimeline1.slice();
-    updateSegmentTimeline?.(oldTimeline1, newTimeline1);
+    expect(updateSegmentTimeline?.(oldTimeline1, newTimeline1)).toEqual(false);
     expect(oldTimeline1).toEqual([...oldTimeline1Cloned, ...newTimeline1Cloned]);
     expect(logWarnSpy).not.toHaveBeenCalled();
 
@@ -129,7 +134,7 @@ describe("Manifest Parsers utils - updateSegmentTimeline", () => {
                            { start: 25100, duration: 1000, repeatCount: 1 } ];
     const oldTimeline2Cloned = oldTimeline2.slice();
     const newTimeline2Cloned = newTimeline2.slice();
-    updateSegmentTimeline?.(oldTimeline2, newTimeline2);
+    expect(updateSegmentTimeline?.(oldTimeline2, newTimeline2)).toEqual(false);
     expect(oldTimeline2).toEqual([...oldTimeline2Cloned, ...newTimeline2Cloned]);
     expect(logWarnSpy).not.toHaveBeenCalled();
   });
@@ -142,7 +147,7 @@ describe("Manifest Parsers utils - updateSegmentTimeline", () => {
     const newTimeline1 = [ { start: 12000, duration: 1000, repeatCount: 11 },
                            { start: 24000, duration: 1100, repeatCount: 0 },
                            { start: 25100, duration: 1000, repeatCount: 1 } ];
-    updateSegmentTimeline?.(oldTimeline1, newTimeline1);
+    expect(updateSegmentTimeline?.(oldTimeline1, newTimeline1)).toEqual(false);
     expect(oldTimeline1).toEqual([
       { start: 0, duration: 500, repeatCount: 20 },
       { start: 11000, duration: 1000, repeatCount: 0 },
@@ -156,7 +161,7 @@ describe("Manifest Parsers utils - updateSegmentTimeline", () => {
     const newTimeline2 = [ { start: 20000, duration: 1000, repeatCount: 3 },
                            { start: 24000, duration: 1100, repeatCount: 0 },
                            { start: 25100, duration: 1000, repeatCount: 1 } ];
-    updateSegmentTimeline?.(oldTimeline2, newTimeline2);
+    expect(updateSegmentTimeline?.(oldTimeline2, newTimeline2)).toEqual(false);
     expect(oldTimeline2).toEqual([
       { start: 0, duration: 500, repeatCount: 20 },
       { start: 11000, duration: 1000, repeatCount: 8 },
@@ -175,7 +180,7 @@ describe("Manifest Parsers utils - updateSegmentTimeline", () => {
                            { start: 1500, duration: 1000, repeatCount: 0 },
                            { start: 2500, duration: 500, repeatCount: 0 },
                            { start: 3000, duration: 5000, repeatCount: 0 } ];
-    updateSegmentTimeline?.(oldTimeline1, newTimeline1);
+    expect(updateSegmentTimeline?.(oldTimeline1, newTimeline1)).toEqual(false);
     expect(oldTimeline1).toEqual([
       { start: 0, duration: 1000, repeatCount: 0 },
       { start: 1000, duration: 500, repeatCount: 0 },
@@ -194,7 +199,7 @@ describe("Manifest Parsers utils - updateSegmentTimeline", () => {
                            { start: 12000, duration: 1000, repeatCount: 0 },
                            { start: 13000, duration: 7000, repeatCount: 0 },
                            { start: 20000, duration: 5000, repeatCount: 0 } ];
-    updateSegmentTimeline?.(oldTimeline1, newTimeline1);
+    expect(updateSegmentTimeline?.(oldTimeline1, newTimeline1)).toEqual(false);
     expect(oldTimeline1).toEqual([
       { start: 0, duration: 1000, repeatCount: 0 },
       { start: 1000, duration: 500, repeatCount: 21 },
@@ -210,7 +215,7 @@ describe("Manifest Parsers utils - updateSegmentTimeline", () => {
                            { start: 12000, duration: 1000, repeatCount: 0 },
                            { start: 13000, duration: 7000, repeatCount: 0 },
                            { start: 20000, duration: 5000, repeatCount: 0 } ];
-    updateSegmentTimeline?.(oldTimeline2, newTimeline2);
+    expect(updateSegmentTimeline?.(oldTimeline2, newTimeline2)).toEqual(false);
     expect(oldTimeline2).toEqual([
       { start: 1000, duration: 500, repeatCount: 21 },
       { start: 12000, duration: 1000, repeatCount: 0 },
@@ -224,7 +229,7 @@ describe("Manifest Parsers utils - updateSegmentTimeline", () => {
                            { start: 12000, duration: 1000, repeatCount: 0 },
                            { start: 13000, duration: 7000, repeatCount: 0 },
                            { start: 20000, duration: 5000, repeatCount: 0 } ];
-    updateSegmentTimeline?.(oldTimeline3, newTimeline3);
+    expect(updateSegmentTimeline?.(oldTimeline3, newTimeline3)).toEqual(false);
     expect(oldTimeline3).toEqual([
       { start: 1000, duration: 500, repeatCount: -1 },
       { start: 12000, duration: 1000, repeatCount: 0 },
@@ -242,7 +247,7 @@ describe("Manifest Parsers utils - updateSegmentTimeline", () => {
                            { start: 12000, duration: 1000, repeatCount: 0 },
                            { start: 13000, duration: 7000, repeatCount: 0 },
                            { start: 20000, duration: 5000, repeatCount: 0 } ];
-    updateSegmentTimeline?.(oldTimeline1, newTimeline1);
+    expect(updateSegmentTimeline?.(oldTimeline1, newTimeline1)).toEqual(false);
     expect(oldTimeline1).toEqual([
       { start: 0, duration: 1000, repeatCount: 0 },
       { start: 1000, duration: 500, repeatCount: 0 },
@@ -259,7 +264,7 @@ describe("Manifest Parsers utils - updateSegmentTimeline", () => {
                            { start: 12000, duration: 1000, repeatCount: 0 },
                            { start: 13000, duration: 7000, repeatCount: 0 },
                            { start: 20000, duration: 5000, repeatCount: 0 } ];
-    updateSegmentTimeline?.(oldTimeline2, newTimeline2);
+    expect(updateSegmentTimeline?.(oldTimeline2, newTimeline2)).toEqual(false);
     expect(oldTimeline2).toEqual([
       { start: 0, duration: 1000, repeatCount: 0 },
       { start: 1000, duration: 500, repeatCount: 3 },
@@ -282,7 +287,7 @@ describe("Manifest Parsers utils - updateSegmentTimeline", () => {
                            { start: 12700, duration: 1000, repeatCount: 0 },
                            { start: 13700, duration: 7000, repeatCount: 0 },
                            { start: 20700, duration: 5000, repeatCount: 0 } ];
-    updateSegmentTimeline?.(oldTimeline1, newTimeline1);
+    expect(updateSegmentTimeline?.(oldTimeline1, newTimeline1)).toEqual(false);
     expect(oldTimeline1).toEqual([
       { start: 0, duration: 1000, repeatCount: 0 },
       { start: 1000, duration: 500, repeatCount: 2 },
@@ -303,7 +308,7 @@ describe("Manifest Parsers utils - updateSegmentTimeline", () => {
                            { start: 12700, duration: 1000, repeatCount: 0 },
                            { start: 13700, duration: 7000, repeatCount: 0 },
                            { start: 20700, duration: 5000, repeatCount: 0 } ];
-    updateSegmentTimeline?.(oldTimeline2, newTimeline2);
+    expect(updateSegmentTimeline?.(oldTimeline2, newTimeline2)).toEqual(false);
     expect(oldTimeline2).toEqual([
       { start: 0, duration: 1000, repeatCount: 0 },
       { start: 1000, duration: 500, repeatCount: 2 },
@@ -321,7 +326,7 @@ describe("Manifest Parsers utils - updateSegmentTimeline", () => {
     const oldTimeline3 = [ { start: 0, duration: 1000, repeatCount: 0 },
                            { start: 1000, duration: 500, repeatCount: 21 } ];
     const newTimeline3 = [ { start: 2700, duration: 500, repeatCount: 19 } ];
-    updateSegmentTimeline?.(oldTimeline3, newTimeline3);
+    expect(updateSegmentTimeline?.(oldTimeline3, newTimeline3)).toEqual(false);
     expect(oldTimeline3).toEqual([
       { start: 0, duration: 1000, repeatCount: 0 },
       { start: 1000, duration: 500, repeatCount: 2 },
@@ -343,7 +348,7 @@ describe("Manifest Parsers utils - updateSegmentTimeline", () => {
                            { start: 12000, duration: 1000, repeatCount: 0 },
                            { start: 13000, duration: 7000, repeatCount: 0 },
                            { start: 20000, duration: 5000, repeatCount: 0 } ];
-    updateSegmentTimeline?.(oldTimeline1, newTimeline1);
+    expect(updateSegmentTimeline?.(oldTimeline1, newTimeline1)).toEqual(false);
     expect(oldTimeline1).toEqual([
       { start: 0, duration: 1000, repeatCount: 0 },
       { start: 1000, duration: 500, repeatCount: 1 },
@@ -364,7 +369,7 @@ describe("Manifest Parsers utils - updateSegmentTimeline", () => {
                            { start: 12000, duration: 1000, repeatCount: 0 },
                            { start: 13000, duration: 7000, repeatCount: 0 },
                            { start: 20000, duration: 5000, repeatCount: 0 } ];
-    updateSegmentTimeline?.(oldTimeline2, newTimeline2);
+    expect(updateSegmentTimeline?.(oldTimeline2, newTimeline2)).toEqual(false);
     expect(oldTimeline2).toEqual([
       { start: 0, duration: 1000, repeatCount: 0 },
       { start: 1000, duration: 500, repeatCount: 1 },
@@ -381,7 +386,7 @@ describe("Manifest Parsers utils - updateSegmentTimeline", () => {
 
     const oldTimeline3 = [ { start: 1000, duration: 500, repeatCount: 21 } ];
     const newTimeline3 = [ { start: 2000, duration: 1000, repeatCount: 9 } ];
-    updateSegmentTimeline?.(oldTimeline3, newTimeline3);
+    expect(updateSegmentTimeline?.(oldTimeline3, newTimeline3)).toEqual(false);
     expect(oldTimeline3).toEqual([
       { start: 1000, duration: 500, repeatCount: 1 },
       { start: 2000, duration: 1000, repeatCount: 9 },
@@ -402,10 +407,8 @@ describe("Manifest Parsers utils - updateSegmentTimeline", () => {
                            { start: 12000, duration: 1000, repeatCount: 0 },
                            { start: 13000, duration: 7000, repeatCount: 0 },
                            { start: 20000, duration: 5000, repeatCount: 0 } ];
-    updateSegmentTimeline?.(oldTimeline1, newTimeline1);
+    expect(updateSegmentTimeline?.(oldTimeline1, newTimeline1)).toEqual(true);
     expect(oldTimeline1).toEqual([
-      { start: 0, duration: 1000, repeatCount: 0 },
-      { start: 1000, duration: 500, repeatCount: 0 },
       { start: 2000, duration: 1000, repeatCount: 0 },
       { start: 3000, duration: 9000, repeatCount: 0 },
       { start: 12000, duration: 1000, repeatCount: 0 },
@@ -414,7 +417,7 @@ describe("Manifest Parsers utils - updateSegmentTimeline", () => {
     ]);
     expect(logWarnSpy).toHaveBeenCalledTimes(1);
     expect(logWarnSpy).toHaveBeenCalledWith(
-      "RepresentationIndex: Manifest update removed previous segments"
+      "RepresentationIndex: Manifest update removed all previous segments"
     );
   });
 
@@ -424,7 +427,7 @@ describe("Manifest Parsers utils - updateSegmentTimeline", () => {
     const oldTimeline1 = [ { start: 0, duration: 1000, repeatCount: 0 },
                            { start: 1000, duration: 500, repeatCount: 21 } ];
     const newTimeline1 = [ { start: 1000, duration: 500, repeatCount: 51 } ];
-    updateSegmentTimeline?.(oldTimeline1, newTimeline1);
+    expect(updateSegmentTimeline?.(oldTimeline1, newTimeline1)).toEqual(false);
     expect(oldTimeline1).toEqual([
       { start: 0, duration: 1000, repeatCount: 0 },
       { start: 1000, duration: 500, repeatCount: 51 },
@@ -432,13 +435,13 @@ describe("Manifest Parsers utils - updateSegmentTimeline", () => {
 
     const oldTimeline2 = [ { start: 1000, duration: 500, repeatCount: 64 } ];
     const newTimeline2 = [ { start: 1000, duration: 500, repeatCount: 72 } ];
-    updateSegmentTimeline?.(oldTimeline2, newTimeline2);
+    expect(updateSegmentTimeline?.(oldTimeline2, newTimeline2)).toEqual(false);
     expect(oldTimeline2).toEqual([ { start: 1000, duration: 500, repeatCount: 72 } ]);
 
     const oldTimeline3 = [ { start: 1000, duration: 500, repeatCount: 64 } ];
     const newTimeline3 = [ { start: 1000, duration: 500, repeatCount: 72 },
                            { start: 37500, duration: 1000, repeatCount: 5 }];
-    updateSegmentTimeline?.(oldTimeline3, newTimeline3);
+    expect(updateSegmentTimeline?.(oldTimeline3, newTimeline3)).toEqual(false);
     expect(oldTimeline3).toEqual([
       { start: 1000, duration: 500, repeatCount: 72 },
       { start: 37500, duration: 1000, repeatCount: 5 },
@@ -455,7 +458,7 @@ describe("Manifest Parsers utils - updateSegmentTimeline", () => {
                            { start: 12000, duration: 1000, repeatCount: 0 },
                            { start: 13000, duration: 7000, repeatCount: 0 },
                            { start: 20000, duration: 5000, repeatCount: 0 } ];
-    updateSegmentTimeline?.(oldTimeline1, newTimeline1);
+    expect(updateSegmentTimeline?.(oldTimeline1, newTimeline1)).toEqual(true);
     expect(oldTimeline1).toEqual([
       { start: 0, duration: 1000, repeatCount: 0 },
       { start: 1000, duration: 500, repeatCount: 21 },
@@ -479,7 +482,7 @@ describe("Manifest Parsers utils - updateSegmentTimeline", () => {
                            { start: 12000, duration: 1000, repeatCount: 0 },
                            { start: 13000, duration: 7000, repeatCount: 0 },
                            { start: 20000, duration: 5000, repeatCount: 0 } ];
-    updateSegmentTimeline?.(oldTimeline2, newTimeline2);
+    expect(updateSegmentTimeline?.(oldTimeline2, newTimeline2)).toEqual(true);
     expect(oldTimeline2).toEqual([
       { start: 0, duration: 1000, repeatCount: 0 },
       { start: 1000, duration: 500, repeatCount: 21 },
@@ -502,7 +505,7 @@ describe("Manifest Parsers utils - updateSegmentTimeline", () => {
                            { start: 20000, duration: 5000, repeatCount: 0 } ];
     const newTimeline1 = [ { start: 0, duration: 1000, repeatCount: 0 },
                            { start: 1000, duration: 500, repeatCount: 21 } ];
-    updateSegmentTimeline?.(oldTimeline1, newTimeline1);
+    expect(updateSegmentTimeline?.(oldTimeline1, newTimeline1)).toEqual(false);
     expect(oldTimeline1).toEqual([
       { start: 1000, duration: 500, repeatCount: 21 },
       { start: 12000, duration: 1000, repeatCount: 0 },
@@ -524,7 +527,7 @@ describe("Manifest Parsers utils - updateSegmentTimeline", () => {
                            { start: 20000, duration: 5000, repeatCount: -1 } ];
     const newTimeline2 = [ { start: 0, duration: 1000, repeatCount: 0 },
                            { start: 1000, duration: 500, repeatCount: 21 } ];
-    updateSegmentTimeline?.(oldTimeline2, newTimeline2);
+    expect(updateSegmentTimeline?.(oldTimeline2, newTimeline2)).toEqual(false);
     expect(oldTimeline2).toEqual([
       { start: 1000, duration: 500, repeatCount: 21 },
       { start: 12000, duration: 1000, repeatCount: 0 },

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

@@ -63,13 +63,13 @@ export default function checkManifestIDs(
         } else {
           adaptationIDs.push(adaptationID);
         }
-        const representationIDs : string[] = [];
+        const representationIDs : Array<number|string> = [];
         adaptation.representations.forEach(representation => {
           const representationID = representation.id;
           if (arrayIncludes(representationIDs, representationID)) {
             log.warn("Two representations with the same ID found. Updating.",
                      representationID);
-            const newID =  representationID + "-dup";
+            const newID = `${representationID}-dup`;
             representation.id = newID;
             checkManifestIDs(manifest);
             representationIDs.push(newID);

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

@@ -20,27 +20,33 @@ import { IIndexSegment } from "./index_helpers";
  * Remove segments which starts before the given `firstAvailablePosition` from
  * the timeline. `firstAvailablePosition` has to be time scaled.
  * @param {Array.<Object>}
- * @returns {number}
+ * @returns {number} - Returns the number of removed segments. This includes
+ * potential implicit segment from decremented `repeatCount` attributes.
  */
 export default function clearTimelineFromPosition(
   timeline : IIndexSegment[],
   firstAvailablePosition : number
-) : void {
+) : number {
+  let nbEltsRemoved = 0;
   while (timeline.length > 0) {
     const firstElt = timeline[0];
     if (firstElt.start >= firstAvailablePosition) {
-      return; // all clear
+      return nbEltsRemoved; // all clear
     }
 
-    if (firstElt.repeatCount <= 0) {
+    if (firstElt.repeatCount === -1) {
+      return nbEltsRemoved;
+    } else if (firstElt.repeatCount === 0) {
       timeline.shift();
+      nbEltsRemoved += 1;
     } else { // we have a segment repetition
       const nextElt = timeline[1];
-      if (nextElt != null && nextElt.start <= firstAvailablePosition) {
+      if (nextElt !== undefined && nextElt.start <= firstAvailablePosition) {
         timeline.shift();
+        nbEltsRemoved += 1;
       } else { // no next segment or next segment is available
         if (firstElt.duration <= 0) {
-          return;
+          return nbEltsRemoved;
         }
 
         let nextStart = firstElt.start + firstElt.duration;
@@ -53,13 +59,16 @@ export default function clearTimelineFromPosition(
         }
         if (nextRepeat > firstElt.repeatCount) { // every start is before
           timeline.shift();
+          nbEltsRemoved = firstElt.repeatCount + 1;
         } else { // some repetitions start after and some before
           const newRepeat = firstElt.repeatCount - nextRepeat;
           firstElt.start = nextStart;
           firstElt.repeatCount = newRepeat;
-          return;
+          nbEltsRemoved += nextRepeat;
+          return nbEltsRemoved;
         }
       }
     }
   }
+  return nbEltsRemoved;
 }