rx-player 3.25.2 → 3.26.3-dev.2022021400

package/src/manifest/__tests__/update_period_in_place.test.ts

@@ -15,47 +15,50 @@
  */
 
 import log from "../../log";
+import type Period from "../period";
 import { MANIFEST_UPDATE_TYPE } from "../types";
 import updatePeriodInPlace from "../update_period_in_place";
 
-const oldVideoRepresentation1 = { parsingErrors: [],
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+const oldVideoRepresentation1 = { contentWarnings: [],
                                   id: "rep-video-1",
                                   index: { _update() { /* noop */ },
                                            _replace() { /* noop */ } } };
-const oldVideoRepresentation2 = { parsingErrors: [],
+const oldVideoRepresentation2 = { contentWarnings: [],
                                   id: "rep-video-2",
                                   index: { _update() { /* noop */ },
                                            _replace() { /* noop */ } } };
-const oldVideoRepresentation3 = { parsingErrors: [],
+const oldVideoRepresentation3 = { contentWarnings: [],
                                   id: "rep-video-3",
                                   index: { _update() { /* noop */ },
                                            _replace() { /* noop */ } } };
-const oldVideoRepresentation4 = { parsingErrors: [],
+const oldVideoRepresentation4 = { contentWarnings: [],
                                   id: "rep-video-4",
                                   index: { _update() { /* noop */ },
                                            _replace() { /* noop */ } } };
-const oldAudioRepresentation = { parsingErrors: [],
+const oldAudioRepresentation = { contentWarnings: [],
                                  id: "rep-audio-1",
                                  index: { _update() { /* noop */ },
                                           _replace() { /* noop */ } } };
 
-const newVideoRepresentation1 = { parsingErrors: [],
+const newVideoRepresentation1 = { contentWarnings: [],
                                   id: "rep-video-1",
                                   index: { _update() { /* noop */ },
                                            _replace() { /* noop */ } } };
-const newVideoRepresentation2 = { parsingErrors: [],
+const newVideoRepresentation2 = { contentWarnings: [],
                                   id: "rep-video-2",
                                   index: { _update() { /* noop */ },
                                            _replace() { /* noop */ } } };
-const newVideoRepresentation3 = { parsingErrors: [],
+const newVideoRepresentation3 = { contentWarnings: [],
                                   id: "rep-video-3",
                                   index: { _update() { /* noop */ },
                                            _replace() { /* noop */ } } };
-const newVideoRepresentation4 = { parsingErrors: [],
+const newVideoRepresentation4 = { contentWarnings: [],
                                   id: "rep-video-4",
                                   index: { _update() { /* noop */ },
                                            _replace() { /* noop */ } } };
-const newAudioRepresentation = { parsingErrors: [],
+const newAudioRepresentation = { contentWarnings: [],
                                  id: "rep-audio-1",
                                  index: { _update() { /* noop */ },
                                           _replace() { /* noop */ } } };
@@ -151,19 +154,19 @@ describe("Manifest - updatePeriodInPlace", () => {
 /* eslint-disable max-len */
   it("should fully update the first Period given by the second one in a full update", () => {
 /* eslint-enable max-len */
-    const oldVideoAdaptation1 = { parsingErrors: [],
+    const oldVideoAdaptation1 = { contentWarnings: [],
                                   id: "ada-video-1",
                                   representations: [oldVideoRepresentation1,
                                                     oldVideoRepresentation2] };
-    const oldVideoAdaptation2 = { parsingErrors: [],
+    const oldVideoAdaptation2 = { contentWarnings: [],
                                   id: "ada-video-2",
                                   representations: [oldVideoRepresentation3,
                                                     oldVideoRepresentation4] };
-    const oldAudioAdaptation = { parsingErrors: [],
+    const oldAudioAdaptation = { contentWarnings: [],
                                  id: "ada-audio-1",
                                  representations: [oldAudioRepresentation] };
     const oldPeriod = {
-      parsingErrors: [],
+      contentWarnings: [],
       start: 5,
       end: 15,
       duration: 10,
@@ -176,19 +179,19 @@ describe("Manifest - updatePeriodInPlace", () => {
                 oldAudioAdaptation];
       },
     };
-    const newVideoAdaptation1 = { parsingErrors: [],
+    const newVideoAdaptation1 = { contentWarnings: [],
                                   id: "ada-video-1",
                                   representations: [newVideoRepresentation1,
                                                     newVideoRepresentation2] };
-    const newVideoAdaptation2 = { parsingErrors: [],
+    const newVideoAdaptation2 = { contentWarnings: [],
                                   id: "ada-video-2",
                                   representations: [newVideoRepresentation3,
                                                     newVideoRepresentation4] };
-    const newAudioAdaptation = { parsingErrors: [],
+    const newAudioAdaptation = { contentWarnings: [],
                                  id: "ada-audio-1",
                                  representations: [newAudioRepresentation] };
     const newPeriod = {
-      parsingErrors: [],
+      contentWarnings: [],
       start: 500,
       end: 520,
       duration: 20,
@@ -206,7 +209,9 @@ describe("Manifest - updatePeriodInPlace", () => {
     const newPeriodAdaptationsSpy = jest.spyOn(newPeriod, "getAdaptations");
     const logSpy = jest.spyOn(log, "warn");
 
-    updatePeriodInPlace(oldPeriod as any, newPeriod as any, MANIFEST_UPDATE_TYPE.Full);
+    updatePeriodInPlace(oldPeriod as unknown as Period,
+                        newPeriod as unknown as Period,
+                        MANIFEST_UPDATE_TYPE.Full);
 
     expect(oldPeriod.start).toEqual(500);
     expect(oldPeriod.end).toEqual(520);
@@ -262,19 +267,19 @@ describe("Manifest - updatePeriodInPlace", () => {
 /* eslint-disable max-len */
   it("should partially update the first Period given by the second one in a partial update", () => {
 /* eslint-enable max-len */
-    const oldVideoAdaptation1 = { parsingErrors: [],
+    const oldVideoAdaptation1 = { contentWarnings: [],
                                   id: "ada-video-1",
                                   representations: [oldVideoRepresentation1,
                                                     oldVideoRepresentation2] };
-    const oldVideoAdaptation2 = { parsingErrors: [],
+    const oldVideoAdaptation2 = { contentWarnings: [],
                                   id: "ada-video-2",
                                   representations: [oldVideoRepresentation3,
                                                     oldVideoRepresentation4] };
-    const oldAudioAdaptation = { parsingErrors: [],
+    const oldAudioAdaptation = { contentWarnings: [],
                                  id: "ada-audio-1",
                                  representations: [oldAudioRepresentation] };
     const oldPeriod = {
-      parsingErrors: [],
+      contentWarnings: [],
       start: 5,
       end: 15,
       duration: 10,
@@ -287,19 +292,19 @@ describe("Manifest - updatePeriodInPlace", () => {
                 oldAudioAdaptation];
       },
     };
-    const newVideoAdaptation1 = { parsingErrors: [],
+    const newVideoAdaptation1 = { contentWarnings: [],
                                   id: "ada-video-1",
                                   representations: [newVideoRepresentation1,
                                                     newVideoRepresentation2] };
-    const newVideoAdaptation2 = { parsingErrors: [],
+    const newVideoAdaptation2 = { contentWarnings: [],
                                   id: "ada-video-2",
                                   representations: [newVideoRepresentation3,
                                                     newVideoRepresentation4] };
-    const newAudioAdaptation = { parsingErrors: [],
+    const newAudioAdaptation = { contentWarnings: [],
                                  id: "ada-audio-1",
                                  representations: [newAudioRepresentation] };
     const newPeriod = {
-      parsingErrors: [],
+      contentWarnings: [],
       start: 500,
       end: 520,
       duration: 20,
@@ -317,7 +322,9 @@ describe("Manifest - updatePeriodInPlace", () => {
     const newPeriodAdaptationsSpy = jest.spyOn(newPeriod, "getAdaptations");
     const logSpy = jest.spyOn(log, "warn");
 
-    updatePeriodInPlace(oldPeriod as any, newPeriod as any, MANIFEST_UPDATE_TYPE.Partial);
+    updatePeriodInPlace(oldPeriod as unknown as Period,
+                        newPeriod as unknown as Period,
+                        MANIFEST_UPDATE_TYPE.Partial);
 
     expect(oldPeriod.start).toEqual(500);
     expect(oldPeriod.end).toEqual(520);
@@ -371,15 +378,15 @@ describe("Manifest - updatePeriodInPlace", () => {
   });
 
   it("should do nothing with new Adaptations", () => {
-    const oldVideoAdaptation1 = { parsingErrors: [],
+    const oldVideoAdaptation1 = { contentWarnings: [],
                                   id: "ada-video-1",
                                   representations: [oldVideoRepresentation1,
                                                     oldVideoRepresentation2] };
-    const oldAudioAdaptation = { parsingErrors: [],
+    const oldAudioAdaptation = { contentWarnings: [],
                                  id: "ada-audio-1",
                                  representations: [oldAudioRepresentation] };
     const oldPeriod = {
-      parsingErrors: [],
+      contentWarnings: [],
       start: 5,
       end: 15,
       duration: 10,
@@ -390,19 +397,19 @@ describe("Manifest - updatePeriodInPlace", () => {
                 oldAudioAdaptation];
       },
     };
-    const newVideoAdaptation1 = { parsingErrors: [],
+    const newVideoAdaptation1 = { contentWarnings: [],
                                   id: "ada-video-1",
                                   representations: [newVideoRepresentation1,
                                                     newVideoRepresentation2] };
-    const newVideoAdaptation2 = { parsingErrors: [],
+    const newVideoAdaptation2 = { contentWarnings: [],
                                   id: "ada-video-2",
                                   representations: [newVideoRepresentation3,
                                                     newVideoRepresentation4] };
-    const newAudioAdaptation = { parsingErrors: [],
+    const newAudioAdaptation = { contentWarnings: [],
                                  id: "ada-audio-1",
                                  representations: [newAudioRepresentation] };
     const newPeriod = {
-      parsingErrors: [],
+      contentWarnings: [],
       start: 500,
       end: 520,
       duration: 20,
@@ -417,29 +424,33 @@ describe("Manifest - updatePeriodInPlace", () => {
     };
 
     const logSpy = jest.spyOn(log, "warn");
-    updatePeriodInPlace(oldPeriod as any, newPeriod as any, MANIFEST_UPDATE_TYPE.Full);
+    updatePeriodInPlace(oldPeriod as unknown as Period,
+                        newPeriod as unknown as Period,
+                        MANIFEST_UPDATE_TYPE.Full);
     expect(logSpy).not.toHaveBeenCalled();
     expect(oldPeriod.adaptations.video).toHaveLength(1);
-    updatePeriodInPlace(oldPeriod as any, newPeriod as any, MANIFEST_UPDATE_TYPE.Partial);
+    updatePeriodInPlace(oldPeriod as unknown as Period,
+                        newPeriod as unknown as Period,
+                        MANIFEST_UPDATE_TYPE.Partial);
     expect(logSpy).not.toHaveBeenCalled();
     expect(oldPeriod.adaptations.video).toHaveLength(1);
     logSpy.mockRestore();
   });
 
   it("should warn if an old Adaptation is not found", () => {
-    const oldVideoAdaptation1 = { parsingErrors: [],
+    const oldVideoAdaptation1 = { contentWarnings: [],
                                   id: "ada-video-1",
                                   representations: [oldVideoRepresentation1,
                                                     oldVideoRepresentation2] };
-    const oldVideoAdaptation2 = { parsingErrors: [],
+    const oldVideoAdaptation2 = { contentWarnings: [],
                                   id: "ada-video-2",
                                   representations: [oldVideoRepresentation3,
                                                     oldVideoRepresentation4] };
-    const oldAudioAdaptation = { parsingErrors: [],
+    const oldAudioAdaptation = { contentWarnings: [],
                                  id: "ada-audio-1",
                                  representations: [oldAudioRepresentation] };
     const oldPeriod = {
-      parsingErrors: [],
+      contentWarnings: [],
       start: 500,
       end: 520,
       duration: 20,
@@ -452,15 +463,15 @@ describe("Manifest - updatePeriodInPlace", () => {
                 oldAudioAdaptation];
       },
     };
-    const newVideoAdaptation1 = { parsingErrors: [],
+    const newVideoAdaptation1 = { contentWarnings: [],
                                   id: "ada-video-1",
                                   representations: [newVideoRepresentation1,
                                                     newVideoRepresentation2] };
-    const newAudioAdaptation = { parsingErrors: [],
+    const newAudioAdaptation = { contentWarnings: [],
                                  id: "ada-audio-1",
                                  representations: [newAudioRepresentation] };
     const newPeriod = {
-      parsingErrors: [],
+      contentWarnings: [],
       start: 5,
       end: 15,
       duration: 10,
@@ -472,14 +483,18 @@ describe("Manifest - updatePeriodInPlace", () => {
     };
 
     const logSpy = jest.spyOn(log, "warn");
-    updatePeriodInPlace(oldPeriod as any, newPeriod as any, MANIFEST_UPDATE_TYPE.Full);
+    updatePeriodInPlace(oldPeriod as unknown as Period,
+                        newPeriod as unknown as Period,
+                        MANIFEST_UPDATE_TYPE.Full);
     expect(logSpy).toHaveBeenCalledTimes(1);
     expect(logSpy).toHaveBeenCalledWith(
       "Manifest: Adaptation \"ada-video-2\" not found when merging."
     );
     expect(oldPeriod.adaptations.video).toHaveLength(2);
     logSpy.mockClear();
-    updatePeriodInPlace(oldPeriod as any, newPeriod as any, MANIFEST_UPDATE_TYPE.Partial);
+    updatePeriodInPlace(oldPeriod as unknown as Period,
+                        newPeriod as unknown as Period,
+                        MANIFEST_UPDATE_TYPE.Partial);
     expect(logSpy).toHaveBeenCalledTimes(1);
     expect(logSpy).toHaveBeenCalledWith(
       "Manifest: Adaptation \"ada-video-2\" not found when merging."
@@ -489,13 +504,13 @@ describe("Manifest - updatePeriodInPlace", () => {
   });
 
   it("should do nothing with new Representations", () => {
-    const oldVideoAdaptation1 = { parsingErrors: [],
+    const oldVideoAdaptation1 = { contentWarnings: [],
                                   id: "ada-video-1",
                                   representations: [oldVideoRepresentation1] };
-    const oldAudioAdaptation = { parsingErrors: [],
+    const oldAudioAdaptation = { contentWarnings: [],
                                  id: "ada-audio-1",
                                  representations: [oldAudioRepresentation] };
-    const oldPeriod = { parsingErrors: [],
+    const oldPeriod = { contentWarnings: [],
                         start: 5,
                         end: 15,
                         duration: 10,
@@ -504,15 +519,15 @@ describe("Manifest - updatePeriodInPlace", () => {
                         getAdaptations() { return [oldVideoAdaptation1,
                                                    oldAudioAdaptation]; } };
 
-    const newVideoAdaptation1 = { parsingErrors: [],
+    const newVideoAdaptation1 = { contentWarnings: [],
                                   id: "ada-video-1",
                                   representations: [newVideoRepresentation1,
                                                     newVideoRepresentation2] };
-    const newAudioAdaptation = { parsingErrors: [],
+    const newAudioAdaptation = { contentWarnings: [],
                                  id: "ada-audio-1",
                                  representations: [newAudioRepresentation] };
     const newPeriod = {
-      parsingErrors: [],
+      contentWarnings: [],
       start: 500,
       end: 520,
       duration: 20,
@@ -524,24 +539,28 @@ describe("Manifest - updatePeriodInPlace", () => {
     };
 
     const logSpy = jest.spyOn(log, "warn");
-    updatePeriodInPlace(oldPeriod as any, newPeriod as any, MANIFEST_UPDATE_TYPE.Full);
+    updatePeriodInPlace(oldPeriod as unknown as Period,
+                        newPeriod as unknown as Period,
+                        MANIFEST_UPDATE_TYPE.Full);
     expect(logSpy).not.toHaveBeenCalled();
     expect(oldVideoAdaptation1.representations).toHaveLength(1);
-    updatePeriodInPlace(oldPeriod as any, newPeriod as any, MANIFEST_UPDATE_TYPE.Partial);
+    updatePeriodInPlace(oldPeriod as unknown as Period,
+                        newPeriod as unknown as Period,
+                        MANIFEST_UPDATE_TYPE.Partial);
     expect(logSpy).not.toHaveBeenCalled();
     expect(oldVideoAdaptation1.representations).toHaveLength(1);
     logSpy.mockRestore();
   });
 
   it("should warn if an old Representation is not found", () => {
-    const oldVideoAdaptation1 = { parsingErrors: [],
+    const oldVideoAdaptation1 = { contentWarnings: [],
                                   id: "ada-video-1",
                                   representations: [oldVideoRepresentation1,
                                                     oldVideoRepresentation2] };
-    const oldAudioAdaptation = { parsingErrors: [],
+    const oldAudioAdaptation = { contentWarnings: [],
                                  id: "ada-audio-1",
                                  representations: [oldAudioRepresentation] };
-    const oldPeriod = { parsingErrors: [],
+    const oldPeriod = { contentWarnings: [],
                         start: 500,
                         end: 520,
                         duration: 20,
@@ -549,13 +568,13 @@ describe("Manifest - updatePeriodInPlace", () => {
                                        audio: [oldAudioAdaptation] },
                         getAdaptations() { return [oldVideoAdaptation1,
                                                    oldAudioAdaptation]; } };
-    const newVideoAdaptation1 = { parsingErrors: [],
+    const newVideoAdaptation1 = { contentWarnings: [],
                                   id: "ada-video-1",
                                   representations: [newVideoRepresentation1] };
-    const newAudioAdaptation = { parsingErrors: [],
+    const newAudioAdaptation = { contentWarnings: [],
                                  id: "ada-audio-1",
                                  representations: [newAudioRepresentation] };
-    const newPeriod = { parsingErrors: [],
+    const newPeriod = { contentWarnings: [],
                         start: 5,
                         end: 15,
                         duration: 10,
@@ -568,14 +587,18 @@ describe("Manifest - updatePeriodInPlace", () => {
     };
 
     const logSpy = jest.spyOn(log, "warn");
-    updatePeriodInPlace(oldPeriod as any, newPeriod as any, MANIFEST_UPDATE_TYPE.Full);
+    updatePeriodInPlace(oldPeriod as unknown as Period,
+                        newPeriod as unknown as Period,
+                        MANIFEST_UPDATE_TYPE.Full);
     expect(logSpy).toHaveBeenCalledTimes(1);
     expect(logSpy).toHaveBeenCalledWith(
       "Manifest: Representation \"rep-video-2\" not found when merging."
     );
     expect(oldVideoAdaptation1.representations).toHaveLength(2);
     logSpy.mockClear();
-    updatePeriodInPlace(oldPeriod as any, newPeriod as any, MANIFEST_UPDATE_TYPE.Partial);
+    updatePeriodInPlace(oldPeriod as unknown as Period,
+                        newPeriod as unknown as Period,
+                        MANIFEST_UPDATE_TYPE.Partial);
     expect(logSpy).toHaveBeenCalledTimes(1);
     expect(logSpy).toHaveBeenCalledWith(
       "Manifest: Representation \"rep-video-2\" not found when merging."

package/src/manifest/__tests__/update_periods.test.ts

@@ -20,6 +20,7 @@
 /* eslint-disable @typescript-eslint/no-unsafe-call */
 /* eslint-disable @typescript-eslint/no-unsafe-assignment */
 /* eslint-disable @typescript-eslint/no-unsafe-return */
+/* eslint-disable @typescript-eslint/no-explicit-any */
 
 const MANIFEST_UPDATE_TYPE = {
   Full: 0,
@@ -304,9 +305,14 @@ describe("updatePeriods", () => {
       error = e;
     }
 
-    expect(error).not.toBeNull();
-    expect(error.type).toEqual("MEDIA_ERROR");
-    expect(error.code).toEqual("MANIFEST_UPDATE_ERROR");
+    expect(error).toBeInstanceOf(Error);
+
+    // Impossible check to shut-up TypeScript
+    if (!(error instanceof Error)) {
+      throw new Error("Impossible: already checked it was an Error instance");
+    }
+    expect((error as { type? : string }).type).toEqual("MEDIA_ERROR");
+    expect((error as { code? : string }).code).toEqual("MANIFEST_UPDATE_ERROR");
     expect(error.message).toEqual(
       "MediaError (MANIFEST_UPDATE_ERROR) Cannot perform partial update: not enough data"
     );
@@ -370,9 +376,14 @@ describe("updatePeriods", () => {
       error = e;
     }
 
-    expect(error).not.toBeNull();
-    expect(error.type).toEqual("MEDIA_ERROR");
-    expect(error.code).toEqual("MANIFEST_UPDATE_ERROR");
+    expect(error).toBeInstanceOf(Error);
+
+    // Impossible check to shut-up TypeScript
+    if (!(error instanceof Error)) {
+      throw new Error("Impossible: already checked it was an Error instance");
+    }
+    expect((error as { type? : string }).type).toEqual("MEDIA_ERROR");
+    expect((error as { code? : string }).code).toEqual("MANIFEST_UPDATE_ERROR");
     expect(error.message).toEqual(
       "MediaError (MANIFEST_UPDATE_ERROR) Cannot perform partial update: incoherent data"
     );
@@ -437,9 +448,14 @@ describe("updatePeriods", () => {
       error = e;
     }
 
-    expect(error).not.toBeNull();
-    expect(error.type).toEqual("MEDIA_ERROR");
-    expect(error.code).toEqual("MANIFEST_UPDATE_ERROR");
+    expect(error).toBeInstanceOf(Error);
+
+    // Impossible check to shut-up TypeScript
+    if (!(error instanceof Error)) {
+      throw new Error("Impossible: already checked it was an Error instance");
+    }
+    expect((error as { type? : string }).type).toEqual("MEDIA_ERROR");
+    expect((error as { code? : string }).code).toEqual("MANIFEST_UPDATE_ERROR");
     expect(error.message).toEqual(
       "MediaError (MANIFEST_UPDATE_ERROR) Cannot perform partial update: not enough data"
     );
@@ -493,9 +509,14 @@ describe("updatePeriods", () => {
       error = e;
     }
 
-    expect(error).not.toBeNull();
-    expect(error.type).toEqual("MEDIA_ERROR");
-    expect(error.code).toEqual("MANIFEST_UPDATE_ERROR");
+    expect(error).toBeInstanceOf(Error);
+
+    // Impossible check to shut-up TypeScript
+    if (!(error instanceof Error)) {
+      throw new Error("Impossible: already checked it was an Error instance");
+    }
+    expect((error as { type? : string }).type).toEqual("MEDIA_ERROR");
+    expect((error as { code? : string }).code).toEqual("MANIFEST_UPDATE_ERROR");
     expect(error.message).toEqual(
       "MediaError (MANIFEST_UPDATE_ERROR) Cannot perform partial update: incoherent data"
     );

package/src/manifest/adaptation.ts

@@ -14,19 +14,16 @@
  * limitations under the License.
  */
 
-import {
-  ICustomError,
-  MediaError,
-} from "../errors";
-import log from "../log";
 import { IParsedAdaptation } from "../parsers/manifest";
 import arrayFind from "../utils/array_find";
-import arrayIncludes from "../utils/array_includes";
 import isNullOrUndefined from "../utils/is_null_or_undefined";
 import normalizeLanguage from "../utils/languages";
 import uniq from "../utils/uniq";
 import Representation from "./representation";
-import { IAdaptationType } from "./types";
+import {
+  IAdaptationType,
+  IExposedRepresentation,
+} from "./types";
 
 /** List in an array every possible value for the Adaptation's `type` property. */
 export const SUPPORTED_ADAPTATIONS_TYPE: IAdaptationType[] = [ "audio",
@@ -34,31 +31,20 @@ export const SUPPORTED_ADAPTATIONS_TYPE: IAdaptationType[] = [ "audio",
                                                                "text",
                                                                "image" ];
 
-/**
- * Returns true if the given Adaptation's `type` is a valid `type` property.
- * @param {string} adaptationType
- * @returns {boolean}
- */
-function isSupportedAdaptationType(
-  adaptationType : string
-) : adaptationType is IAdaptationType {
-  return arrayIncludes(SUPPORTED_ADAPTATIONS_TYPE, adaptationType);
-}
-
 /**
  * Information describing a single Representation from an Adaptation, to be used
  * in the `representationFilter` API.
  */
 export interface IRepresentationInfos { bufferType: IAdaptationType;
-                                        language?: string;
-                                        isAudioDescription? : boolean;
-                                        isClosedCaption? : boolean;
-                                        isDub? : boolean;
-                                        isSignInterpreted?: boolean;
-                                        normalizedLanguage? : string; }
+                                        language?: string | undefined;
+                                        isAudioDescription? : boolean | undefined;
+                                        isClosedCaption? : boolean | undefined;
+                                        isDub? : boolean | undefined;
+                                        isSignInterpreted?: boolean | undefined;
+                                        normalizedLanguage? : string | undefined; }
 
 /** Type for the `representationFilter` API. */
-export type IRepresentationFilter = (representation: Representation,
+export type IRepresentationFilter = (representation: IExposedRepresentation,
                                      adaptationInfos: IRepresentationInfos) => boolean;
 
 /**
@@ -115,12 +101,6 @@ export default class Adaptation {
   /** Tells if the track is a trick mode track. */
   public isTrickModeTrack? : boolean;
 
-  /**
-   * Array containing every errors that happened when the Adaptation has been
-   * created, in the order they have happened.
-   */
-  public readonly parsingErrors : ICustomError[];
-
   public readonly trickModeTracks? : Adaptation[];
 
   /**
@@ -129,25 +109,18 @@ export default class Adaptation {
    * @param {Object|undefined} [options]
    */
   constructor(parsedAdaptation : IParsedAdaptation, options : {
-    representationFilter? : IRepresentationFilter;
-    isManuallyAdded? : boolean;
+    representationFilter? : IRepresentationFilter | undefined;
+    isManuallyAdded? : boolean | undefined;
   } = {}) {
     const { trickModeTracks } = parsedAdaptation;
     const { representationFilter, isManuallyAdded } = options;
-    this.parsingErrors = [];
     this.id = parsedAdaptation.id;
-    this.isTrickModeTrack = parsedAdaptation.isTrickModeTrack;
-
-    if (!isSupportedAdaptationType(parsedAdaptation.type)) {
-      log.info("Manifest: Not supported adaptation type", parsedAdaptation.type);
-      /* eslint-disable @typescript-eslint/restrict-template-expressions */
-      throw new MediaError("MANIFEST_UNSUPPORTED_ADAPTATION_TYPE",
-                           `"${parsedAdaptation.type}" is not a valid ` +
-                           "Adaptation type.");
-      /* eslint-enable @typescript-eslint/restrict-template-expressions */
-    }
     this.type = parsedAdaptation.type;
 
+    if  (parsedAdaptation.isTrickModeTrack !== undefined) {
+      this.isTrickModeTrack = parsedAdaptation.isTrickModeTrack;
+    }
+
     if (parsedAdaptation.language !== undefined) {
       this.language = parsedAdaptation.language;
       this.normalizedLanguage = normalizeLanguage(parsedAdaptation.language);
@@ -201,13 +174,6 @@ export default class Adaptation {
 
     // for manuallyAdded adaptations (not in the manifest)
     this.manuallyAdded = isManuallyAdded === true;
-
-    if (this.representations.length > 0 && !isSupported) {
-      log.warn("Incompatible codecs for adaptation", parsedAdaptation);
-      const error = new MediaError("MANIFEST_INCOMPATIBLE_CODECS_ERROR",
-                                   "An Adaptation contains only incompatible codecs.");
-      this.parsingErrors.push(error);
-    }
   }
 
   /**

package/src/manifest/index.ts

@@ -16,9 +16,9 @@
 
 import Adaptation, {
   IRepresentationFilter,
+  IRepresentationInfos,
   SUPPORTED_ADAPTATIONS_TYPE,
 } from "./adaptation";
-import areSameContent from "./are_same_content";
 import Manifest, {
   IManifestParsingOptions,
   ISupplementaryImageTrack,
@@ -33,12 +33,23 @@ import {
   ISegment,
   StaticRepresentationIndex,
 } from "./representation_index";
-import { IAdaptationType } from "./types";
+import {
+  IAdaptationType,
+  IHDRInformation,
+} from "./types";
+import {
+  areSameContent,
+  getLoggableSegmentId,
+  IBufferedChunkInfos,
+} from "./utils";
 
 export default Manifest;
+export * from "./types";
 export {
   // utils
   areSameContent,
+  getLoggableSegmentId,
+  IBufferedChunkInfos,
 
   // classes
   Period,
@@ -48,9 +59,11 @@ export {
   // types
   IAdaptationType,
   IBaseContentInfos,
+  IHDRInformation,
   IManifestParsingOptions,
   IMetaPlaylistPrivateInfos,
   IRepresentationFilter,
+  IRepresentationInfos,
   IRepresentationIndex,
   ISegment,
   ISupplementaryImageTrack,