rx-player 3.26.2 → 3.27.0-dev.20220317

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,7 +93,7 @@ describe("Manifest Parsers utils - updateSegmentTimeline", () => {
 
     let err = null;
     try {
-      updateSegmentTimeline?.(oldTimeline1, newTimeline1);
+      expect(updateSegmentTimeline?.(oldTimeline1, newTimeline1)).not.toHaveReturned();
     } catch (e) {
       err = e;
     }
@@ -121,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();
 
@@ -134,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();
   });
@@ -147,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 },
@@ -161,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 },
@@ -180,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 },
@@ -199,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 },
@@ -215,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 },
@@ -229,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 },
@@ -247,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 },
@@ -264,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 },
@@ -287,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 },
@@ -308,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 },
@@ -326,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 },
@@ -348,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 },
@@ -369,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 },
@@ -386,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 },
@@ -407,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 },
@@ -419,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"
     );
   });
 
@@ -429,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 },
@@ -437,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 },
@@ -460,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 },
@@ -484,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 },
@@ -507,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 },
@@ -529,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/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 !== 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;
 }

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

@@ -28,7 +28,7 @@ export interface IIndexSegment {
    */
   repeatCount: number;
   /** Optional byte-range the segment is available at when requested. */
-  range?: [number, number];
+  range?: [number, number] | undefined;
 }
 
 /**
@@ -42,7 +42,7 @@ export interface IIndexSegment {
 export function calculateRepeat(
   element : IIndexSegment,
   nextElement? : IIndexSegment | null | undefined,
-  maxPosition? : number
+  maxPosition? : number | undefined
 ) : number {
   const { repeatCount } = element;
 

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

@@ -24,22 +24,31 @@ import {
 /**
  * Update a complete array of segments in a given timeline with a [generally]
  * smaller but [generally] newer set of segments.
+ *
+ * Returns a boolean:
+ *   - If set to `true`, the old timeline was emptied and completely replaced by
+ *     the content of the newer timeline.
+ *     This could happen either if a problem happened while trying to update or
+ *     when the update is actually bigger than what it is updating.
+ *   - If set to `false`, the older timeline was either updated to add the newer
+ *     segments, or untouched.
+ *
  * @param {Array.<Object>} oldTimeline
  * @param {Array.<Object>} newTimeline
+ * @returns {boolean}
  */
 export default function updateSegmentTimeline(
   oldTimeline : IIndexSegment[],
   newTimeline : IIndexSegment[]
-) : void {
-  const prevTimelineLength = oldTimeline.length;
+) : boolean {
   if (oldTimeline.length === 0) {
-    oldTimeline.splice(0, prevTimelineLength, ...newTimeline);
-    return;
-  }
-  if (newTimeline.length === 0) {
-    return;
+    oldTimeline.push(...newTimeline);
+    return true;
+  } else if (newTimeline.length === 0) {
+    return false;
   }
 
+  const prevTimelineLength = oldTimeline.length;
   const newIndexStart = newTimeline[0].start;
 
   const oldLastElt = oldTimeline[prevTimelineLength - 1];
@@ -53,29 +62,31 @@ export default function updateSegmentTimeline(
     const currStart = oldTimeline[i].start;
     if (currStart === newIndexStart) {
       // replace that one and those after it
-      oldTimeline.splice(i, prevTimelineLength - i, ...newTimeline);
-      return;
+      const nbEltsToRemove = prevTimelineLength - i;
+      oldTimeline.splice(i, nbEltsToRemove, ...newTimeline);
+      return false;
     } else if (currStart < newIndexStart) { // first to be before
       const currElt = oldTimeline[i];
       if (currElt.start + currElt.duration > newIndexStart) {
-        // the new Manifest overlaps a previous segment (weird). Remove the latter.
-        log.warn("RepresentationIndex: Manifest update removed previous segments");
-        oldTimeline.splice(i, prevTimelineLength - i, ...newTimeline);
-        return;
+        // The new Manifest overlaps a previous segment (weird)
+        // In that improbable case, we'll just completely replace segments
+        log.warn("RepresentationIndex: Manifest update removed all previous segments");
+        oldTimeline.splice(0, prevTimelineLength, ...newTimeline);
+        return true;
       } else if (currElt.repeatCount === undefined || currElt.repeatCount <= 0) {
         if (currElt.repeatCount < 0) {
           currElt.repeatCount = Math.floor((newIndexStart - currElt.start) /
                                               currElt.duration) - 1;
         }
         oldTimeline.splice(i + 1, prevTimelineLength - (i + 1), ...newTimeline);
-        return;
+        return false;
       }
       // else, there is a positive repeat we might want to update
       const eltLastTime = currElt.start + currElt.duration * (currElt.repeatCount + 1);
       if (eltLastTime <= newIndexStart) { // our new index comes directly after
         // put it after this one
         oldTimeline.splice(i + 1, prevTimelineLength - (i + 1), ...newTimeline);
-        return;
+        return false;
       }
 
       const newCurrRepeat = ((newIndexStart - currElt.start) / currElt.duration) - 1;
@@ -88,14 +99,14 @@ export default function updateSegmentTimeline(
         oldTimeline.splice(i, prevTimelineLength - i, ...newTimeline);
         oldTimeline[i].start = currElt.start;
         oldTimeline[i].repeatCount = newRepeatCount;
-        return;
+        return false;
       }
       log.warn("RepresentationIndex: Manifest update removed previous segments");
       oldTimeline[i].repeatCount = Math.floor(newCurrRepeat);
 
       // put it after this one
       oldTimeline.splice(i + 1, prevTimelineLength - (i + 1), ...newTimeline);
-      return;
+      return false;
     }
   }
 
@@ -107,11 +118,11 @@ export default function updateSegmentTimeline(
   if (prevLastElt.repeatCount !== undefined && prevLastElt.repeatCount < 0) {
     if (prevLastElt.start > newLastElt.start) {
       log.warn("RepresentationIndex: The new index is older than the previous one");
-      return; // the old comes after
+      return false;
     } else { // the new has more depth
       log.warn("RepresentationIndex: The new index is \"bigger\" than the previous one");
       oldTimeline.splice(0, prevTimelineLength, ...newTimeline);
-      return;
+      return true;
     }
   }
   const prevLastTime = prevLastElt.start + prevLastElt.duration *
@@ -120,11 +131,11 @@ export default function updateSegmentTimeline(
                       (newLastElt.repeatCount + 1);
   if (prevLastTime >= newLastTime) {
     log.warn("RepresentationIndex: The new index is older than the previous one");
-    return; // the old comes after
+    return false;
   }
 
   // the new one has more depth. full update
   log.warn("RepresentationIndex: The new index is \"bigger\" than the previous one");
   oldTimeline.splice(0, prevTimelineLength, ...newTimeline);
-  return;
+  return true;
 }

package/src/parsers/texttracks/webvtt/html/__tests__/create_styled_element.test.ts

@@ -75,6 +75,7 @@ describe("parsers - webvtt - createStyledElement", () => {
     node.appendChild(textNode);
 
     const styleElements = {
+      // eslint-disable-next-line @typescript-eslint/naming-convention
       "#text": "color: yellow",
     };
 

package/src/parsers/texttracks/webvtt/html/to_html.ts

@@ -39,10 +39,10 @@ export default function toHTML(
   cueObj : { start : number;
              end : number;
              settings: Partial<Record<string, string>>;
-             header? : string;
+             header? : string | undefined;
              payload : string[]; },
   styling : { classes : IStyleElements;
-              global? : string; }
+              global? : string | undefined; }
 ) : IVTTHTMLCue {
   const { start, end, settings, header, payload } = cueObj;
 

package/src/parsers/texttracks/webvtt/parse_cue_block.ts

@@ -78,7 +78,7 @@ function parseTimeAndSettings(
 
 export interface IVTTCueObject { start : number;
                                  end : number;
-                                 header? : string;
+                                 header : string | undefined;
                                  settings: Partial<Record<string, string>>;
                                  payload : string[]; }
 

package/src/public_types.ts

@@ -45,13 +45,17 @@ export {
   ITextTrackPreference,
   IVideoTrackPreference,
 
+  IBitrateEstimate,
+  IPositionUpdateItem as IPositionUpdate,
+  IPlayerState,
+
   IStreamEvent,
   IStreamEventData,
 } from "./core/api";
 export {
   IPersistentSessionInfo,
   IPersistentSessionStorage,
-} from "./core/eme";
+} from "./core/decrypt";
 export { ICustomError as IPlayerError } from "./errors";
 export {
   IExposedAdaptation as IAdaptation,

package/src/transports/dash/add_segment_integrity_checks_to_loader.ts

@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+import PPromise from "../../utils/promise";
 import TaskCanceller, {
   CancellationError,
 } from "../../utils/task_canceller";
@@ -32,8 +33,7 @@ export default function addSegmentIntegrityChecks<T>(
   segmentLoader : ISegmentLoader<T>
 ) : ISegmentLoader<T> {
   return (url, content, initialCancelSignal, callbacks) => {
-    return new Promise((res, rej) => {
-
+    return new PPromise((res, rej) => {
       const canceller = new TaskCanceller();
       const unregisterCancelLstnr = initialCancelSignal
         .register(function onCheckCancellation(err : CancellationError) {

package/src/transports/dash/image_pipelines.ts

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-import PPromise from "pinkie";
 import features from "../../features";
+import PPromise from "../../utils/promise";
 import request from "../../utils/request";
 import takeFirstSet from "../../utils/take_first_set";
 import { CancellationSignal } from "../../utils/task_canceller";
@@ -78,6 +78,7 @@ export function imageParser(
   if (content.segment.isInit) { // image init segment has no use
     return { segmentType: "init",
              initializationData: null,
+             initializationDataSize: 0,
              protectionDataUpdate: false,
              initTimescale: undefined };
   }
@@ -92,6 +93,7 @@ export function imageParser(
   if (data === null || features.imageParser === null) {
     return { segmentType: "media",
              chunkData: null,
+             chunkSize: 0,
              chunkInfos: { duration: segment.duration,
                            time: segment.time },
              chunkOffset,
@@ -107,6 +109,7 @@ export function imageParser(
                         end: Number.MAX_VALUE,
                         timescale: 1,
                         type: "bif" },
+           chunkSize: undefined,
            chunkInfos: { time: 0,
                          duration: Number.MAX_VALUE },
            chunkOffset,

package/src/transports/dash/init_segment_loader.ts

@@ -14,9 +14,9 @@
  * limitations under the License.
  */
 
-import PPromise from "pinkie";
 import { ISegment } from "../../manifest";
 import { concat } from "../../utils/byte_parsing";
+import PPromise from "../../utils/promise";
 import request from "../../utils/request";
 import { CancellationSignal } from "../../utils/task_canceller";
 import {

package/src/transports/dash/manifest_parser.ts

@@ -14,7 +14,6 @@
  * limitations under the License.
  */
 
-import PPromise from "pinkie";
 import { formatError } from "../../errors";
 import features from "../../features";
 import log from "../../log";
@@ -24,6 +23,7 @@ import {
   ILoadedResource,
 } from "../../parsers/manifest/dash/parsers_types";
 import objectAssign from "../../utils/object_assign";
+import PPromise from "../../utils/promise";
 import request from "../../utils/request";
 import {
   strToUtf8,

package/src/transports/dash/segment_loader.ts

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-import PPromise from "pinkie";
 import { CustomLoaderError } from "../../errors";
+import PPromise from "../../utils/promise";
 import request, {
   fetchIsSupported,
 } from "../../utils/request";
@@ -94,8 +94,8 @@ export default function generateSegmentLoader(
   { lowLatencyMode,
     segmentLoader: customSegmentLoader,
     checkMediaSegmentIntegrity } : { lowLatencyMode: boolean;
-                                     segmentLoader? : ICustomSegmentLoader;
-                                     checkMediaSegmentIntegrity? : boolean; }
+                                     segmentLoader? : ICustomSegmentLoader | undefined;
+                                     checkMediaSegmentIntegrity? : boolean | undefined; }
 ) : ISegmentLoader<Uint8Array | ArrayBuffer | null> {
   return checkMediaSegmentIntegrity !== true ? segmentLoader :
                                                addSegmentIntegrityChecks(segmentLoader);
@@ -130,7 +130,7 @@ export default function generateSegmentLoader(
                    transport: "dash",
                    url };
 
-    return new Promise((res, rej) => {
+    return new PPromise((res, rej) => {
       /** `true` when the custom segmentLoader should not be active anymore. */
       let hasFinished = false;
 
@@ -140,8 +140,8 @@ export default function generateSegmentLoader(
        */
       const resolve = (
         _args : { data : ArrayBuffer|Uint8Array;
-                  size? : number;
-                  duration? : number; }
+                  size? : number | undefined;
+                  duration? : number | undefined; }
       ) => {
         if (hasFinished || cancelSignal.isCancelled) {
           return;
@@ -183,7 +183,7 @@ export default function generateSegmentLoader(
       const progress = (
         _args : { duration : number;
                   size : number;
-                  totalSize? : number; }
+                  totalSize? : number | undefined; }
       ) => {
         if (hasFinished || cancelSignal.isCancelled) {
           return;