rx-player 3.25.2 → 3.26.3-dev.2022021400

package/src/experimental/tools/VideoThumbnailLoader/thumbnail_loader.ts

@@ -14,28 +14,28 @@
  * limitations under the License.
  */
 
-import pinkie from "pinkie";
-import {
-  combineLatest,
-  lastValueFrom,
-  merge as observableMerge,
-  race as observableRace,
-  Subject,
-} from "rxjs";
 import {
   catchError,
+  combineLatest,
   finalize,
   ignoreElements,
+  lastValueFrom,
   map,
+  merge as observableMerge,
   mergeMap,
+  race as observableRace,
+  Subject,
   take,
   tap,
-} from "rxjs/operators";
+} from "rxjs";
 import Player from "../../../core/api";
-import createSegmentLoader from "../../../core/fetchers/segment/create_segment_loader";
+import createSegmentFetcher, {
+  ISegmentFetcher,
+} from "../../../core/fetchers/segment/segment_fetcher";
 import log from "../../../log";
 import { ISegment } from "../../../manifest";
 import objectAssign from "../../../utils/object_assign";
+import PPromise from "../../../utils/promise";
 import { freeRequest } from "./create_request";
 import getCompleteSegmentId from "./get_complete_segment_id";
 import getContentInfos from "./get_content_infos";
@@ -52,9 +52,6 @@ import {
 } from "./types";
 import VideoThumbnailLoaderError from "./video_thumbnail_loader_error";
 
-const PPromise = typeof Promise === "function" ? Promise :
-                                                 pinkie;
-
 const MIN_NEEDED_DATA_AFTER_TIME = 2;
 
 interface ITimeSettingTask { contentInfos: IContentInfos;
@@ -75,8 +72,8 @@ export default class VideoThumbnailLoader {
   private readonly _videoElement: HTMLVideoElement;
 
   private _player: Player;
-  private _currentTask?: ITimeSettingTask;
-  private _nextTaskSegmentsCompleteIds?: string[];
+  private _currentTask : ITimeSettingTask | undefined;
+  private _nextTaskSegmentsCompleteIds : string[] | undefined;
   constructor(videoElement: HTMLVideoElement,
               player: Player) {
     this._videoElement = videoElement;
@@ -206,22 +203,22 @@ export default class VideoThumbnailLoader {
       })
     );
 
-    const segmentLoader = createSegmentLoader(
-      loader.video.loader,
-      undefined,
+    const segmentFetcher = createSegmentFetcher(
+      "video",
+      loader.video,
+      // We don't care about the SegmentFetcher's lifecycle events
+      {},
       { baseDelay: 0,
         maxDelay: 0,
         maxRetryOffline: 0,
         maxRetryRegular: 0 }
-    );
-    const { parser: segmentParser } = loader.video;
+    ) as ISegmentFetcher<ArrayBuffer | Uint8Array>;
 
     const taskPromise: Promise<number> = lastValueFrom(observableRace(
       abortError$,
       getInitializedSourceBuffer$(contentInfos,
                                   this._videoElement,
-                                  { segmentLoader,
-                                    segmentParser }).pipe(
+                                  segmentFetcher).pipe(
         mergeMap((videoSourceBuffer) => {
           const bufferCleaning$ = removeBufferAroundTime$(this._videoElement,
                                                           videoSourceBuffer,
@@ -229,7 +226,7 @@ export default class VideoThumbnailLoader {
           log.debug("VTL: Removing buffer around time.", time);
 
           const segmentsLoading$ =
-            loadSegments(segments, segmentLoader, contentInfos);
+            loadSegments(segments, segmentFetcher, contentInfos);
 
           return observableMerge(bufferCleaning$.pipe(ignoreElements()),
                                  segmentsLoading$
@@ -237,18 +234,30 @@ export default class VideoThumbnailLoader {
             mergeMap((arr) => {
               return combineLatest(
                 arr.map(({ segment, data }) => {
-                  const start = segment.time / segment.timescale;
-                  const end = start + (segment.duration / segment.timescale);
+                  if (data.segmentType === "init") {
+                    throw new Error("Unexpected initialization segment parsed.");
+                  }
+                  let start;
+                  let end;
+                  if (data.chunkInfos !== null) {
+                    start = data.chunkInfos.time;
+                    end = data.chunkInfos.duration;
+                  } else {
+                    start = segment.time / segment.timescale;
+                  }
+
+                  if (end === undefined) {
+                    end = start + (segment.duration / segment.timescale);
+                  }
                   const inventoryInfos = objectAssign({ segment,
                                                         start,
                                                         end }, contentInfos);
                   return pushData(inventoryInfos,
-                                  segmentParser,
                                   data,
                                   videoSourceBuffer)
                     .pipe(tap(() => {
                       freeRequest(getCompleteSegmentId(inventoryInfos, segment));
-                      log.debug("VTL: Appended segment.", data);
+                      log.debug("VTL: Appended segment.");
                     }));
                 })
               );
@@ -261,16 +270,8 @@ export default class VideoThumbnailLoader {
         }),
         catchError((err: unknown) => {
           let message = "Unknown error.";
-          if ((err as { message?: string; toString(): string }).message !== undefined ||
-            /* eslint-disable @typescript-eslint/no-unsafe-assignment */
-            /* eslint-disable @typescript-eslint/no-unsafe-member-access */
-            /* eslint-disable @typescript-eslint/no-unsafe-call */
-              typeof (err as { message?: string;
-                               toString(): string; }).toString === "function") {
-            message = (err as any).message ?? (err as any).toString();
-            /* eslint-enable @typescript-eslint/no-unsafe-assignment */
-            /* eslint-enable @typescript-eslint/no-unsafe-member-access */
-            /* eslint-enable @typescript-eslint/no-unsafe-call */
+          if (err instanceof Error) {
+            message = err.message ?? err.toString();
           }
           throw new VideoThumbnailLoaderError("LOADING_ERROR", message);
         })

package/src/experimental/tools/VideoThumbnailLoader/types.ts

@@ -33,5 +33,4 @@ export type ILoaders = Partial<Record<string, ITransportPipelines>>;
 
 export type IThumbnailLoaderSegmentParser =
   ISegmentParser<Uint8Array | ArrayBuffer | null,
-                 Uint8Array | ArrayBuffer | null,
                  Uint8Array | ArrayBuffer | null>;

package/src/experimental/tools/createMetaplaylist/get_duration_from_manifest.ts

@@ -15,13 +15,15 @@
  */
 
 import {
+  map,
   Observable,
   throwError,
 } from "rxjs";
-import { map } from "rxjs/operators";
 import { IMetaPlaylist } from "../../../parsers/manifest/metaplaylist";
 import isNonEmptyString from "../../../utils/is_non_empty_string";
 import request from "../../../utils/request/xhr";
+import fromCancellablePromise from "../../../utils/rx-from_cancellable_promise";
+import TaskCanceller from "../../../utils/task_canceller";
 
 const iso8601Duration =
   /^P(([\d.]*)Y)?(([\d.]*)M)?(([\d.]*)D)?T?(([\d.]*)H)?(([\d.]*)M)?(([\d.]*)S)?/;
@@ -82,58 +84,65 @@ function getDurationFromManifest(url: string,
     return throwError(() => new Error("createMetaplaylist: Unknown transport type."));
   }
 
+  const canceller = new TaskCanceller();
   if (transport === "dash" || transport === "smooth") {
-    return request({ url, responseType: "document" }).pipe(
-      map(({ value }) => {
-        const { responseData } = value;
-        const root = responseData.documentElement;
-        if (transport === "dash") {
-          const dashDurationAttribute = root.getAttribute("mediaPresentationDuration");
-          if (dashDurationAttribute === null) {
-            throw new Error("createMetaplaylist: No duration on DASH content.");
-          }
-          const periodElements = root.getElementsByTagName("Period");
-          const firstDASHStartAttribute = periodElements[0]?.getAttribute("start");
-          const firstDASHStart =
-            firstDASHStartAttribute !== null ? parseDuration(firstDASHStartAttribute) :
-                                               0;
-          const dashDuration = parseDuration(dashDurationAttribute);
-          if (firstDASHStart === null || dashDuration === null) {
-            throw new Error("createMetaplaylist: Cannot parse " +
-                            "the duration from a DASH content.");
-          }
-          return dashDuration - firstDASHStart;
+    return fromCancellablePromise(
+      canceller,
+      () => request({ url,
+                      responseType: "document",
+                      cancelSignal: canceller.signal })
+    ).pipe(map((response) => {
+      const { responseData } = response;
+      const root = responseData.documentElement;
+      if (transport === "dash") {
+        const dashDurationAttribute = root.getAttribute("mediaPresentationDuration");
+        if (dashDurationAttribute === null) {
+          throw new Error("createMetaplaylist: No duration on DASH content.");
         }
-        // smooth
-        const smoothDurationAttribute = root.getAttribute("Duration");
-        const smoothTimeScaleAttribute = root.getAttribute("TimeScale");
-        if (smoothDurationAttribute === null) {
-          throw new Error("createMetaplaylist: No duration on smooth content.");
+        const periodElements = root.getElementsByTagName("Period");
+        const firstDASHStartAttribute = periodElements[0]?.getAttribute("start");
+        const firstDASHStart =
+          firstDASHStartAttribute !== null ? parseDuration(firstDASHStartAttribute) :
+                                             0;
+        const dashDuration = parseDuration(dashDurationAttribute);
+        if (firstDASHStart === null || dashDuration === null) {
+          throw new Error("createMetaplaylist: Cannot parse " +
+                          "the duration from a DASH content.");
         }
-        const timescale = smoothTimeScaleAttribute !== null ?
-          parseInt(smoothTimeScaleAttribute, 10) :
-          10000000;
-        return (parseInt(smoothDurationAttribute, 10)) / timescale;
-      })
-    );
+        return dashDuration - firstDASHStart;
+      }
+      // smooth
+      const smoothDurationAttribute = root.getAttribute("Duration");
+      const smoothTimeScaleAttribute = root.getAttribute("TimeScale");
+      if (smoothDurationAttribute === null) {
+        throw new Error("createMetaplaylist: No duration on smooth content.");
+      }
+      const timescale = smoothTimeScaleAttribute !== null ?
+        parseInt(smoothTimeScaleAttribute, 10) :
+        10000000;
+      return (parseInt(smoothDurationAttribute, 10)) / timescale;
+    }));
   }
 
   // metaplaylist
-  return request({ url, responseType: "text" }).pipe(
-    map(({ value }) => {
-      const { responseData } = value;
-      const metaplaylist = JSON.parse(responseData) as IMetaPlaylist;
-      if (metaplaylist.contents === undefined ||
-          metaplaylist.contents.length === undefined ||
-          metaplaylist.contents.length === 0) {
-        throw new Error("createMetaplaylist: No duration on Metaplaylist content.");
-      }
-      const { contents } = metaplaylist;
-      const lastEnd = contents[contents.length - 1].endTime;
-      const firstStart = contents[0].startTime;
-      return lastEnd - firstStart;
-    })
-  );
+  return fromCancellablePromise(
+    canceller,
+    () => request({ url,
+                    responseType: "text",
+                    cancelSignal: canceller.signal })
+  ).pipe(map((response) => {
+    const { responseData } = response;
+    const metaplaylist = JSON.parse(responseData) as IMetaPlaylist;
+    if (metaplaylist.contents === undefined ||
+        metaplaylist.contents.length === undefined ||
+        metaplaylist.contents.length === 0) {
+      throw new Error("createMetaplaylist: No duration on Metaplaylist content.");
+    }
+    const { contents } = metaplaylist;
+    const lastEnd = contents[contents.length - 1].endTime;
+    const firstStart = contents[0].startTime;
+    return lastEnd - firstStart;
+  }));
 }
 
 export default getDurationFromManifest;

package/src/experimental/tools/createMetaplaylist/index.ts

@@ -17,9 +17,9 @@
 import {
   combineLatest as observableCombineLatest,
   lastValueFrom,
+  map,
   of as observableOf,
 } from "rxjs";
-import { map } from "rxjs/operators";
 import { IMetaPlaylist } from "../../../parsers/manifest/metaplaylist";
 import getDurationFromManifest from "./get_duration_from_manifest";
 

package/src/experimental/tools/mediaCapabilitiesProber/__tests__/probers/DRMInfos.test.ts

@@ -21,8 +21,10 @@
 /* eslint-disable @typescript-eslint/no-unsafe-assignment */
 /* eslint-disable @typescript-eslint/no-unsafe-return */
 
-import { of as observableOf } from "rxjs";
-import { map } from "rxjs/operators";
+import {
+  map,
+  of as observableOf,
+} from "rxjs";
 import { ProberStatus } from "../../types";
 
 
@@ -89,7 +91,7 @@ describe("MediaCapabilitiesProber probers - DRMInfos", () => {
     const probeDRMInfos = require("../../probers/DRMInfos").default;
     expect.assertions(2);
     probeDRMInfos(configuration)
-      .then((res: any) => {
+      .then((res: unknown) => {
         expect(res).toEqual(
           [
             ProberStatus.Supported,
@@ -126,7 +128,7 @@ describe("MediaCapabilitiesProber probers - DRMInfos", () => {
     const probeDRMInfos = require("../../probers/DRMInfos").default;
     expect.assertions(2);
     probeDRMInfos(configuration)
-      .then((res: any) => {
+      .then((res: unknown) => {
         expect(res).toEqual(
           [
             ProberStatus.NotSupported,

package/src/experimental/tools/mediaCapabilitiesProber/__tests__/probers/HDCPPolicy.test.ts

@@ -72,7 +72,7 @@ describe("MediaCapabilitiesProber probers - HDCPPolicy", () => {
 
     expect.assertions(3);
     probeHDCPPolicy({ hdcp: "1.1" })
-      .then(([res]: [any]) => {
+      .then(([res]: [unknown]) => {
         expect(res).toEqual(ProberStatus.Unknown);
         expect(mockCreateMediaKeys).toHaveBeenCalledTimes(1);
         expect(mockRequestMediaKeySystemAcces).toHaveBeenCalledTimes(1);
@@ -102,7 +102,7 @@ describe("MediaCapabilitiesProber probers - HDCPPolicy", () => {
 
     expect.assertions(3);
     probeHDCPPolicy({ hdcp: "1.1" })
-      .then(([res]: [any]) => {
+      .then(([res]: [unknown]) => {
         expect(res).toEqual(ProberStatus.Supported);
         expect(mockCreateMediaKeys).toHaveBeenCalledTimes(1);
         expect(mockRequestMediaKeySystemAcces).toHaveBeenCalledTimes(1);
@@ -132,7 +132,7 @@ describe("MediaCapabilitiesProber probers - HDCPPolicy", () => {
 
     expect.assertions(3);
     probeHDCPPolicy({ hdcp: "1.1" })
-      .then(([res]: [any]) => {
+      .then(([res]: [unknown]) => {
         expect(res).toEqual(ProberStatus.NotSupported);
         expect(mockCreateMediaKeys).toHaveBeenCalledTimes(1);
         expect(mockRequestMediaKeySystemAcces).toHaveBeenCalledTimes(1);

package/src/experimental/tools/mediaCapabilitiesProber/__tests__/probers/decodingInfos.test.ts

@@ -21,6 +21,7 @@
 /* eslint-disable @typescript-eslint/no-unsafe-assignment */
 /* eslint-disable @typescript-eslint/no-unsafe-return */
 /* eslint-disable @typescript-eslint/strict-boolean-expressions */
+/* eslint-disable @typescript-eslint/no-explicit-any */
 
 import PPromise from "../../../../../utils/promise";
 
@@ -31,6 +32,7 @@ import {
 } from "../../types";
 
 const origDecodingInfo = (navigator as any).mediaCapabilities;
+const origMediaCapabilities = (navigator as any).mediaCapabilities;
 
 /**
  * Stub decodingInfo API to resolve.
@@ -67,6 +69,9 @@ describe("MediaCapabilitiesProber probers - decodingInfo", () => {
   beforeEach(() => {
     jest.resetModules();
   });
+  afterEach(() => {
+    (navigator as any).mediaCapabilities = origMediaCapabilities;
+  });
 
   it("should throw if no video and audio config", (done) => {
     const decodingInfoStub = stubDecodingInfo(true);
@@ -179,14 +184,12 @@ describe("MediaCapabilitiesProber probers - decodingInfo", () => {
   });
 
   it("should throw if API mediaCapabilities not available", () => {
-    const origMediaCapabilities = (navigator as any).mediaCapabilities;
     delete (navigator as any).mediaCapabilities;
     /* eslint-disable @typescript-eslint/no-floating-promises */
     expect(probeDecodingInfos({})).rejects.toThrowError(
       "MediaCapabilitiesProber >>> API_CALL: MediaCapabilities API not available"
     );
     /* eslint-enable @typescript-eslint/no-floating-promises */
-    (navigator as any).mediaCapabilities = origMediaCapabilities;
   });
 
   it("should throw if API decodingInfo not available", () => {
@@ -200,11 +203,6 @@ describe("MediaCapabilitiesProber probers - decodingInfo", () => {
       "MediaCapabilitiesProber >>> API_CALL: Decoding Info not available"
     );
     /* eslint-enable @typescript-eslint/no-floating-promises */
-    if ((navigator as any).mediaCapabilities) {
-      (navigator as any).mediaCapabilities.decodingInfo = origDecodingInfo;
-    } else {
-      (navigator as any).mediaCapabilities = undefined;
-    }
   });
 
   it("should resolve with `Supported` if decodingInfo supports (video only)", (done) => {

package/src/experimental/tools/mediaCapabilitiesProber/__tests__/probers/mediaContentType.test.ts

@@ -98,7 +98,7 @@ describe("MediaCapabilitiesProber - probers probeMediaContentType", () => {
 
     expect.assertions(2);
     probeMediaContentType(config)
-      .then(([res]: [any]) => {
+      .then(([res]: [unknown]) => {
         expect(res).toEqual(ProberStatus.Supported);
         expect(mockIsTypeSupported).toHaveBeenCalledTimes(1);
         done();
@@ -125,7 +125,7 @@ describe("MediaCapabilitiesProber - probers probeMediaContentType", () => {
 
     expect.assertions(2);
     probeMediaContentType(config)
-      .then(([res]: [any]) => {
+      .then(([res]: [unknown]) => {
         expect(res).toEqual(ProberStatus.Supported);
         expect(mockIsTypeSupported).toHaveBeenCalledTimes(1);
         done();
@@ -155,7 +155,7 @@ describe("MediaCapabilitiesProber - probers probeMediaContentType", () => {
 
     expect.assertions(2);
     probeMediaContentType(config)
-      .then(([res]: [any]) => {
+      .then(([res]: [unknown]) => {
         expect(res).toEqual(ProberStatus.Supported);
         expect(mockIsTypeSupported).toHaveBeenCalledTimes(1);
         done();
@@ -182,7 +182,7 @@ describe("MediaCapabilitiesProber - probers probeMediaContentType", () => {
 
     expect.assertions(2);
     probeMediaContentType(config)
-      .then(([res]: [any]) => {
+      .then(([res]: [unknown]) => {
         expect(res).toEqual(ProberStatus.NotSupported);
         expect(mockIsTypeSupported).toHaveBeenCalledTimes(1);
         done();
@@ -209,7 +209,7 @@ describe("MediaCapabilitiesProber - probers probeMediaContentType", () => {
 
     expect.assertions(2);
     probeMediaContentType(config)
-      .then(([res]: [any]) => {
+      .then(([res]: [unknown]) => {
         expect(res).toEqual(ProberStatus.NotSupported);
         expect(mockIsTypeSupported).toHaveBeenCalledTimes(1);
         done();
@@ -239,7 +239,7 @@ describe("MediaCapabilitiesProber - probers probeMediaContentType", () => {
 
     expect.assertions(2);
     probeMediaContentType(config)
-      .then(([res]: [any]) => {
+      .then(([res]: [unknown]) => {
         expect(res).toEqual(ProberStatus.NotSupported);
         expect(mockIsTypeSupported).toHaveBeenCalledTimes(1);
         done();
@@ -271,7 +271,7 @@ describe("MediaCapabilitiesProber - probers probeMediaContentType", () => {
 
     expect.assertions(2);
     probeMediaContentType(config)
-      .then(([res]: [any]) => {
+      .then(([res]: [unknown]) => {
         expect(res).toEqual(ProberStatus.NotSupported);
         expect(mockIsTypeSupported).toHaveBeenCalledTimes(1);
         done();

package/src/experimental/tools/mediaCapabilitiesProber/__tests__/probers/mediaDisplayInfos.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 */
 
 
 import { ProberStatus } from "../../types";

package/src/experimental/tools/mediaCapabilitiesProber/api/index.ts

@@ -115,7 +115,7 @@ const mediaCapabilitiesProber = {
   },
 
   /**
-   * From an array of given configurations (type  and key system configuration), return
+   * From an array of given configurations (type and key system configuration), return
    * supported ones.
    * @param {Array.<Object>} configurations
    * @returns {Promise}
@@ -126,7 +126,8 @@ const mediaCapabilitiesProber = {
       configuration: IMediaKeySystemConfiguration;
     }>
   ) : Promise<ICompatibleKeySystem[]> {
-    const promises: Array<Promise<any>> = [];
+    const promises: Array<Promise<{ globalStatus: ProberStatus;
+                                    result? : ICompatibleKeySystem | undefined; }>> = [];
     configurations.forEach((configuration) => {
       const globalConfig = {
         keySystem: configuration,
@@ -152,8 +153,15 @@ const mediaCapabilitiesProber = {
       );
     });
     return PPromise.all(promises)
-      .then((supportedConfigs) => {
-        return supportedConfigs
+      .then((configs) => {
+        // TODO I added those lines to work-around a type issue but does it
+        // really correspond to the original intent? I find it hard to
+        // understand and shouldn't we also rely on things like `globalStatus`
+        // here?
+        return configs
+          .filter((x) : x is { globalStatus : ProberStatus;
+                               result : ICompatibleKeySystem; } =>
+            x.result !== undefined)
           .map(({ result }: { result: ICompatibleKeySystem }) => result);
       });
   },

package/src/experimental/tools/mediaCapabilitiesProber/api/probeMediaConfiguration.ts

@@ -36,7 +36,7 @@ export interface IProbedMediaConfiguration {
   globalStatus: ProberStatus;
   resultsFromAPIS: Array<{
     APIName: ICapabilitiesTypes;
-    result?: IResultsFromAPI;
+    result?: IResultsFromAPI | undefined;
   }>;
 }
 
@@ -63,7 +63,7 @@ function probeMediaConfiguration(
   let globalStatus : ProberStatus|undefined;
   const resultsFromAPIS: Array<{
     APIName: ICapabilitiesTypes;
-    result?: IResultsFromAPI;
+    result: IResultsFromAPI | undefined;
   }> = [];
   const promises = [];
   for (const browserAPI of browserAPIS) {
@@ -103,7 +103,7 @@ function probeMediaConfiguration(
   }
 
   return PPromise.all(promises).then(() => {
-    if (globalStatus == null) {
+    if (globalStatus === undefined) {
       globalStatus = ProberStatus.Unknown;
     }
 

package/src/experimental/tools/mediaCapabilitiesProber/probers/decodingInfo.ts

@@ -36,8 +36,11 @@ function isMediaCapabilitiesAPIAvailable(): Promise<void> {
       throw new Error("MediaCapabilitiesProber >>> API_CALL: " +
         "MediaCapabilities API not available");
     }
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+    /* eslint-disable @typescript-eslint/no-explicit-any */
+    /* eslint-disable @typescript-eslint/no-unsafe-member-access */
     if (!("decodingInfo" in (navigator as any).mediaCapabilities)) {
+    /* eslint-enable @typescript-eslint/no-explicit-any */
+    /* eslint-enable @typescript-eslint/no-unsafe-member-access */
       throw new Error("MediaCapabilitiesProber >>> API_CALL: " +
         "Decoding Info not available");
     }
@@ -78,8 +81,15 @@ export default function probeDecodingInfos(
       "Not enough arguments for calling mediaCapabilites.");
     }
 
-    // eslint-disable-next-line
+    /* eslint-disable @typescript-eslint/no-explicit-any */
+    /* eslint-disable @typescript-eslint/no-unsafe-call */
+    /* eslint-disable @typescript-eslint/no-unsafe-member-access */
+    /* eslint-disable @typescript-eslint/no-unsafe-return */
     return (navigator as any).mediaCapabilities.decodingInfo(config)
+    /* eslint-enable @typescript-eslint/no-explicit-any */
+    /* eslint-enable @typescript-eslint/no-unsafe-call */
+    /* eslint-enable @typescript-eslint/no-unsafe-member-access */
+    /* eslint-enable @typescript-eslint/no-unsafe-return */
       .then((result: IDecodingInfos) => {
         return [
           result.supported ? ProberStatus.Supported : ProberStatus.NotSupported,

package/src/experimental/tools/mediaCapabilitiesProber/probers/mediaContentTypeWithFeatures/index.ts

@@ -38,8 +38,11 @@ function isTypeSupportedWithFeaturesAPIAvailable(): Promise<void> {
       throw new Error("MediaCapabilitiesProber >>> API_CALL: " +
         "MSMediaKeys API not available");
     }
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+    /* eslint-disable @typescript-eslint/no-explicit-any */
+    /* eslint-disable @typescript-eslint/no-unsafe-member-access */
     if (!("isTypeSupportedWithFeatures" in (window as any).MSMediaKeys)) {
+    /* eslint-enable @typescript-eslint/no-explicit-any */
+    /* eslint-enable @typescript-eslint/no-unsafe-member-access */
       throw new Error("MediaCapabilitiesProber >>> API_CALL: " +
         "isTypeSupportedWithFeatures not available");
     }
@@ -72,8 +75,10 @@ export default function probeTypeWithFeatures(
     /* eslint-disable @typescript-eslint/no-unsafe-assignment */
     /* eslint-disable @typescript-eslint/no-unsafe-member-access */
     /* eslint-disable @typescript-eslint/no-unsafe-call */
+    /* eslint-disable @typescript-eslint/no-explicit-any */
     const result: ISupportWithFeatures =
       (window as any).MSMediaKeys.isTypeSupportedWithFeatures(type, features);
+    /* eslint-enable @typescript-eslint/no-explicit-any */
     /* eslint-enable @typescript-eslint/no-unsafe-assignment */
     /* eslint-enable @typescript-eslint/no-unsafe-member-access */
     /* eslint-enable @typescript-eslint/no-unsafe-call */

package/src/experimental/tools/mediaCapabilitiesProber/types.ts

@@ -52,9 +52,9 @@ export interface IDisplayConfiguration {
 }
 
 export interface IMediaConfiguration {
-  type?: "media-source"|"file";
-  video?: IVideoConfiguration;
-  audio?: IAudioConfiguration;
+  type?: "media-source" | "file" | undefined;
+  video?: IVideoConfiguration | undefined;
+  audio?: IAudioConfiguration | undefined;
   keySystem?: IKeySystem;
   hdcp?: string;
   display?: IDisplayConfiguration;