rx-player 4.2.0-dev.2024090300 → 4.2.0-dev.2024090500

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

@@ -1,11 +1,7 @@
 import { describe, beforeEach, it, expect, vi } from "vitest";
+import type IProbeMediaContentType from "../../probers/mediaContentType";
 import { ProberStatus } from "../../types";
-
-/* eslint-disable @typescript-eslint/no-unsafe-member-access */
-/* 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 type { IMediaConfiguration } from "../../types";
 
 describe("MediaCapabilitiesProber - probers probeMediaContentType", () => {
   beforeEach(() => {
@@ -17,13 +13,12 @@ describe("MediaCapabilitiesProber - probers probeMediaContentType", () => {
       MediaSource_: null,
     }));
     const probeMediaContentType = (
-      (await vi.importActual("../../probers/mediaContentType")) as any
-    ).default;
-    /* eslint-disable @typescript-eslint/no-floating-promises */
+      await vi.importActual("../../probers/mediaContentType")
+    ).default as typeof IProbeMediaContentType;
+    // eslint-disable-next-line @typescript-eslint/no-floating-promises
     expect(probeMediaContentType({})).rejects.toThrowError(
       "MediaCapabilitiesProber >>> API_CALL: " + "MediaSource API not available",
     );
-    /* eslint-enable @typescript-eslint/no-floating-promises */
   });
 
   it("should throw if no compatible isTypeSupported API", async () => {
@@ -33,13 +28,12 @@ describe("MediaCapabilitiesProber - probers probeMediaContentType", () => {
       },
     }));
     const probeMediaContentType = (
-      (await vi.importActual("../../probers/mediaContentType")) as any
-    ).default;
-    /* eslint-disable @typescript-eslint/no-floating-promises */
+      await vi.importActual("../../probers/mediaContentType")
+    ).default as typeof IProbeMediaContentType;
+    // eslint-disable-next-line @typescript-eslint/no-floating-promises
     expect(probeMediaContentType({})).rejects.toThrowError(
       "MediaCapabilitiesProber >>> API_CALL: " + "isTypeSupported not available",
     );
-    /* eslint-enable @typescript-eslint/no-floating-promises */
   });
 
   it("should throw if no specified contentType in config", async () => {
@@ -49,12 +43,12 @@ describe("MediaCapabilitiesProber - probers probeMediaContentType", () => {
         isTypeSupported: mockIsTypeSupported,
       },
     }));
-    const config = {
+    const config: IMediaConfiguration = {
       type: "media-source",
     };
     const probeMediaContentType = (
-      (await vi.importActual("../../probers/mediaContentType")) as any
-    ).default;
+      await vi.importActual("../../probers/mediaContentType")
+    ).default as typeof IProbeMediaContentType;
 
     expect.assertions(1);
     await probeMediaContentType(config).catch(({ message }: { message: string }) => {
@@ -72,15 +66,15 @@ describe("MediaCapabilitiesProber - probers probeMediaContentType", () => {
         isTypeSupported: mockIsTypeSupported,
       },
     }));
-    const config = {
+    const config: IMediaConfiguration = {
       type: "media-source",
       video: {
         contentType: "video/mp5",
       },
     };
     const probeMediaContentType = (
-      (await vi.importActual("../../probers/mediaContentType")) as any
-    ).default;
+      await vi.importActual("../../probers/mediaContentType")
+    ).default as typeof IProbeMediaContentType;
 
     expect.assertions(2);
     await probeMediaContentType(config)
@@ -100,15 +94,15 @@ describe("MediaCapabilitiesProber - probers probeMediaContentType", () => {
         isTypeSupported: mockIsTypeSupported,
       },
     }));
-    const config = {
+    const config: IMediaConfiguration = {
       type: "media-source",
       audio: {
         contentType: "audio/wma",
       },
     };
     const probeMediaContentType = (
-      (await vi.importActual("../../probers/mediaContentType")) as any
-    ).default;
+      await vi.importActual("../../probers/mediaContentType")
+    ).default as typeof IProbeMediaContentType;
 
     expect.assertions(2);
     await probeMediaContentType(config)
@@ -128,7 +122,7 @@ describe("MediaCapabilitiesProber - probers probeMediaContentType", () => {
         isTypeSupported: mockIsTypeSupported,
       },
     }));
-    const config = {
+    const config: IMediaConfiguration = {
       type: "media-source",
       audio: {
         contentType: "audio/wma",
@@ -138,8 +132,8 @@ describe("MediaCapabilitiesProber - probers probeMediaContentType", () => {
       },
     };
     const probeMediaContentType = (
-      (await vi.importActual("../../probers/mediaContentType")) as any
-    ).default;
+      await vi.importActual("../../probers/mediaContentType")
+    ).default as typeof IProbeMediaContentType;
 
     expect.assertions(2);
     await probeMediaContentType(config)
@@ -159,15 +153,15 @@ describe("MediaCapabilitiesProber - probers probeMediaContentType", () => {
         isTypeSupported: mockIsTypeSupported,
       },
     }));
-    const config = {
+    const config: IMediaConfiguration = {
       type: "media-source",
       audio: {
         contentType: "audio/wma",
       },
     };
     const probeMediaContentType = (
-      (await vi.importActual("../../probers/mediaContentType")) as any
-    ).default;
+      await vi.importActual("../../probers/mediaContentType")
+    ).default as typeof IProbeMediaContentType;
 
     expect.assertions(2);
     await probeMediaContentType(config)
@@ -187,15 +181,15 @@ describe("MediaCapabilitiesProber - probers probeMediaContentType", () => {
         isTypeSupported: mockIsTypeSupported,
       },
     }));
-    const config = {
+    const config: IMediaConfiguration = {
       type: "media-source",
       video: {
         contentType: "video/mp5",
       },
     };
     const probeMediaContentType = (
-      (await vi.importActual("../../probers/mediaContentType")) as any
-    ).default;
+      await vi.importActual("../../probers/mediaContentType")
+    ).default as typeof IProbeMediaContentType;
 
     expect.assertions(2);
     await probeMediaContentType(config)
@@ -215,7 +209,7 @@ describe("MediaCapabilitiesProber - probers probeMediaContentType", () => {
         isTypeSupported: mockIsTypeSupported,
       },
     }));
-    const config = {
+    const config: IMediaConfiguration = {
       type: "media-source",
       video: {
         contentType: "video/mp5",
@@ -225,8 +219,8 @@ describe("MediaCapabilitiesProber - probers probeMediaContentType", () => {
       },
     };
     const probeMediaContentType = (
-      (await vi.importActual("../../probers/mediaContentType")) as any
-    ).default;
+      await vi.importActual("../../probers/mediaContentType")
+    ).default as typeof IProbeMediaContentType;
 
     expect.assertions(2);
     await probeMediaContentType(config)
@@ -248,7 +242,7 @@ describe("MediaCapabilitiesProber - probers probeMediaContentType", () => {
         isTypeSupported: mockIsTypeSupported,
       },
     }));
-    const config = {
+    const config: IMediaConfiguration = {
       type: "media-source",
       video: {
         contentType: "video/mp5",
@@ -258,8 +252,8 @@ describe("MediaCapabilitiesProber - probers probeMediaContentType", () => {
       },
     };
     const probeMediaContentType = (
-      (await vi.importActual("../../probers/mediaContentType")) as any
-    ).default;
+      await vi.importActual("../../probers/mediaContentType")
+    ).default as typeof IProbeMediaContentType;
 
     expect.assertions(2);
     await probeMediaContentType(config)

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

@@ -1,92 +1,95 @@
 import { describe, it, expect, vi } from "vitest";
 import globalScope from "../../../../../utils/global_scope";
+import type IProbeMediaDisplayInfos from "../../probers/mediaDisplayInfos";
 import { ProberStatus } from "../../types";
 
-/* eslint-disable @typescript-eslint/no-unsafe-member-access */
-/* 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 */
-
 describe("MediaCapabilitiesProber probers probeMediaDisplayInfos", () => {
   it("should throw if matchMedia is undefined", async () => {
-    /* eslint-disable @typescript-eslint/unbound-method */
+    // eslint-disable-next-line @typescript-eslint/unbound-method
     const origMatchMedia = globalScope.matchMedia;
-    /* eslint-enable @typescript-eslint/unbound-method */
-    (globalScope as any).matchMedia = undefined;
+    (
+      globalScope as { matchMedia: typeof globalScope.matchMedia | undefined }
+    ).matchMedia = undefined;
+
     const probeMediaDisplayInfos = (
-      (await vi.importActual("../../probers/mediaDisplayInfos")) as any
-    ).default;
-    /* eslint-disable @typescript-eslint/no-floating-promises */
+      await vi.importActual("../../probers/mediaDisplayInfos")
+    ).default as typeof IProbeMediaDisplayInfos;
+    // eslint-disable-next-line @typescript-eslint/no-floating-promises
     expect(probeMediaDisplayInfos({})).rejects.toThrowError(
       "MediaCapabilitiesProber >>> API_CALL: matchMedia not available",
     );
-    /* eslint-enable @typescript-eslint/no-floating-promises */
-    (globalScope as any).matchMedia = origMatchMedia;
+    (
+      globalScope as { matchMedia: typeof globalScope.matchMedia | undefined }
+    ).matchMedia = origMatchMedia;
   });
 
   it("should throw if no colorSpace in display configuration", async () => {
-    /* eslint-disable @typescript-eslint/unbound-method */
+    // eslint-disable-next-line @typescript-eslint/unbound-method
     const origMatchMedia = globalScope.matchMedia;
-    /* eslint-enable @typescript-eslint/unbound-method */
     const mockMatchMedia = vi.fn(() => true);
-    (globalScope as any).matchMedia = mockMatchMedia;
+    globalScope.matchMedia = mockMatchMedia as unknown as typeof globalScope.matchMedia;
     const config = {
       display: {},
     };
 
     const probeMediaDisplayInfos = (
-      (await vi.importActual("../../probers/mediaDisplayInfos")) as any
-    ).default;
+      await vi.importActual("../../probers/mediaDisplayInfos")
+    ).default as typeof IProbeMediaDisplayInfos;
 
     expect.assertions(1);
     return probeMediaDisplayInfos(config)
       .then(() => {
-        (globalScope as any).matchMedia = origMatchMedia;
+        (
+          globalScope as { matchMedia: typeof globalScope.matchMedia | undefined }
+        ).matchMedia = origMatchMedia;
       })
       .catch(({ message }: { message: string }) => {
         expect(message).toBe(
           "MediaCapabilitiesProber >>> API_CALL: " +
             "Not enough arguments for calling matchMedia.",
         );
-        (globalScope as any).matchMedia = origMatchMedia;
+        (
+          globalScope as { matchMedia: typeof globalScope.matchMedia | undefined }
+        ).matchMedia = origMatchMedia;
       });
   });
 
   it("should throw if no display in configuration", async () => {
-    /* eslint-disable @typescript-eslint/unbound-method */
+    // eslint-disable-next-line @typescript-eslint/unbound-method
     const origMatchMedia = globalScope.matchMedia;
-    /* eslint-enable @typescript-eslint/unbound-method */
     const mockMatchMedia = vi.fn(() => true);
-    (globalScope as any).matchMedia = mockMatchMedia;
+    globalScope.matchMedia = mockMatchMedia as unknown as typeof globalScope.matchMedia;
     const config = {};
 
     const probeMediaDisplayInfos = (
-      (await vi.importActual("../../probers/mediaDisplayInfos")) as any
-    ).default;
+      await vi.importActual("../../probers/mediaDisplayInfos")
+    ).default as typeof IProbeMediaDisplayInfos;
 
     expect.assertions(1);
     return probeMediaDisplayInfos(config)
       .then(() => {
-        (globalScope as any).matchMedia = origMatchMedia;
+        (
+          globalScope as { matchMedia: typeof globalScope.matchMedia | undefined }
+        ).matchMedia = origMatchMedia;
       })
       .catch(({ message }: { message: string }) => {
         expect(message).toBe(
           "MediaCapabilitiesProber >>> API_CALL: " +
             "Not enough arguments for calling matchMedia.",
         );
-        (globalScope as any).matchMedia = origMatchMedia;
+        (
+          globalScope as { matchMedia: typeof globalScope.matchMedia | undefined }
+        ).matchMedia = origMatchMedia;
       });
   });
 
   it("should throw if mediaMatch called with bad arguments", async () => {
-    /* eslint-disable @typescript-eslint/unbound-method */
+    // eslint-disable-next-line @typescript-eslint/unbound-method
     const origMatchMedia = globalScope.matchMedia;
-    /* eslint-enable @typescript-eslint/unbound-method */
     const mockMatchMedia = vi.fn(() => ({
       media: "not all",
     }));
-    (globalScope as any).matchMedia = mockMatchMedia;
+    globalScope.matchMedia = mockMatchMedia as unknown as typeof globalScope.matchMedia;
     const config = {
       display: {
         colorSpace: "srgb",
@@ -94,13 +97,15 @@ describe("MediaCapabilitiesProber probers probeMediaDisplayInfos", () => {
     };
 
     const probeMediaDisplayInfos = (
-      (await vi.importActual("../../probers/mediaDisplayInfos")) as any
-    ).default;
+      await vi.importActual("../../probers/mediaDisplayInfos")
+    ).default as typeof IProbeMediaDisplayInfos;
 
     expect.assertions(2);
     return probeMediaDisplayInfos(config)
       .then(() => {
-        (globalScope as any).matchMedia = origMatchMedia;
+        (
+          globalScope as { matchMedia: typeof globalScope.matchMedia | undefined }
+        ).matchMedia = origMatchMedia;
       })
       .catch(({ message }: { message: string }) => {
         expect(message).toBe(
@@ -108,18 +113,19 @@ describe("MediaCapabilitiesProber probers probeMediaDisplayInfos", () => {
             "Bad arguments for calling matchMedia.",
         );
         expect(mockMatchMedia).toHaveBeenCalledTimes(1);
-        (globalScope as any).matchMedia = origMatchMedia;
+        (
+          globalScope as { matchMedia: typeof globalScope.matchMedia | undefined }
+        ).matchMedia = origMatchMedia;
       });
   });
 
   it("should resolves with `Supported` if color space is supported", async () => {
-    /* eslint-disable @typescript-eslint/unbound-method */
+    // eslint-disable-next-line @typescript-eslint/unbound-method
     const origMatchMedia = globalScope.matchMedia;
-    /* eslint-enable @typescript-eslint/unbound-method */
     const mockMatchMedia = vi.fn(() => ({
       matches: true,
     }));
-    (globalScope as any).matchMedia = mockMatchMedia;
+    globalScope.matchMedia = mockMatchMedia as unknown as typeof globalScope.matchMedia;
     const config = {
       display: {
         colorSpace: "srgb",
@@ -127,29 +133,32 @@ describe("MediaCapabilitiesProber probers probeMediaDisplayInfos", () => {
     };
 
     const probeMediaDisplayInfos = (
-      (await vi.importActual("../../probers/mediaDisplayInfos")) as any
-    ).default;
+      await vi.importActual("../../probers/mediaDisplayInfos")
+    ).default as typeof IProbeMediaDisplayInfos;
 
     expect.assertions(2);
     return probeMediaDisplayInfos(config)
-      .then(([res]: [any]) => {
+      .then(([res]) => {
         expect(res).toEqual(ProberStatus.Supported);
         expect(mockMatchMedia).toHaveBeenCalledTimes(1);
-        (globalScope as any).matchMedia = origMatchMedia;
+        (
+          globalScope as { matchMedia: typeof globalScope.matchMedia | undefined }
+        ).matchMedia = origMatchMedia;
       })
       .catch(() => {
-        (globalScope as any).matchMedia = origMatchMedia;
+        (
+          globalScope as { matchMedia: typeof globalScope.matchMedia | undefined }
+        ).matchMedia = origMatchMedia;
       });
   });
 
   it("should resolves with `NotSupported` if color space is not supported", async () => {
-    /* eslint-disable @typescript-eslint/unbound-method */
+    // eslint-disable-next-line @typescript-eslint/unbound-method
     const origMatchMedia = globalScope.matchMedia;
-    /* eslint-enable @typescript-eslint/unbound-method */
     const mockMatchMedia = vi.fn(() => ({
       matches: false,
     }));
-    (globalScope as any).matchMedia = mockMatchMedia;
+    globalScope.matchMedia = mockMatchMedia as unknown as typeof globalScope.matchMedia;
     const config = {
       display: {
         colorSpace: "p5",
@@ -157,18 +166,22 @@ describe("MediaCapabilitiesProber probers probeMediaDisplayInfos", () => {
     };
 
     const probeMediaDisplayInfos = (
-      (await vi.importActual("../../probers/mediaDisplayInfos")) as any
-    ).default;
+      await vi.importActual("../../probers/mediaDisplayInfos")
+    ).default as typeof IProbeMediaDisplayInfos;
 
     expect.assertions(2);
     return probeMediaDisplayInfos(config)
-      .then(([res]: [any]) => {
+      .then(([res]) => {
         expect(res).toEqual(ProberStatus.NotSupported);
         expect(mockMatchMedia).toHaveBeenCalledTimes(1);
-        (globalScope as any).matchMedia = origMatchMedia;
+        (
+          globalScope as { matchMedia: typeof globalScope.matchMedia | undefined }
+        ).matchMedia = origMatchMedia;
       })
       .catch(() => {
-        (globalScope as any).matchMedia = origMatchMedia;
+        (
+          globalScope as { matchMedia: typeof globalScope.matchMedia | undefined }
+        ).matchMedia = origMatchMedia;
       });
   });
 });

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

@@ -34,11 +34,7 @@ function isMediaCapabilitiesAPIAvailable(): Promise<void> {
         "MediaCapabilitiesProber >>> API_CALL: " + "MediaCapabilities API not available",
       );
     }
-    /* 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 */
+    if (!("decodingInfo" in navigator.mediaCapabilities)) {
       throw new Error(
         "MediaCapabilitiesProber >>> API_CALL: " + "Decoding Info not available",
       );
@@ -54,7 +50,6 @@ function isMediaCapabilitiesAPIAvailable(): Promise<void> {
 export default function probeDecodingInfos(
   config: IMediaConfiguration,
 ): Promise<[ProberStatus]> {
-  // eslint-disable-next-line @typescript-eslint/no-unsafe-return
   return isMediaCapabilitiesAPIAvailable().then(() => {
     const hasVideoConfig =
       config.type !== undefined &&
@@ -86,21 +81,13 @@ export default function probeDecodingInfos(
       );
     }
 
-    /* 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)
-      .then((result: IDecodingInfos) => {
+    return navigator.mediaCapabilities
+      .decodingInfo(config as unknown as MediaDecodingConfiguration)
+      .then((result: IDecodingInfos): [ProberStatus] => {
         return [result.supported ? ProberStatus.Supported : ProberStatus.NotSupported];
       })
       .catch(() => {
         return [ProberStatus.NotSupported];
       });
-    /* 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 */
   });
 }

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

@@ -30,12 +30,10 @@ export function findDefaultVideoCodec(): string {
     'video/mp4;codecs="hvc1.1.6.L93.B0"',
     'video/webm;codecs="vp8"',
   ];
-  /* eslint-disable @typescript-eslint/unbound-method */
   if (
     isNullOrUndefined(MediaSource_) ||
     typeof MediaSource_.isTypeSupported !== "function"
   ) {
-    /* eslint-enable @typescript-eslint/unbound-method */
     throw new Error("Cannot check video codec support: No API available.");
   }
   for (const codec of videoCodecs) {
@@ -54,12 +52,10 @@ export function findDefaultVideoCodec(): string {
  */
 export function findDefaultAudioCodec(): string {
   const audioCodecs = ['audio/mp4;codecs="mp4a.40.2"', "audio/webm;codecs=opus"];
-  /* eslint-disable @typescript-eslint/unbound-method */
   if (
     isNullOrUndefined(MediaSource_) ||
     typeof MediaSource_.isTypeSupported !== "function"
   ) {
-    /* eslint-enable @typescript-eslint/unbound-method */
     throw new Error("Cannot check audio codec support: No API available.");
   }
   for (const codec of audioCodecs) {

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

@@ -32,9 +32,8 @@ export default function probeContentType(
         "MediaCapabilitiesProber >>> API_CALL: " + "MediaSource API not available",
       );
     }
-    /* eslint-disable @typescript-eslint/unbound-method */
+    // eslint-disable-next-line @typescript-eslint/unbound-method
     if (typeof MediaSource_.isTypeSupported !== "function") {
-      /* eslint-enable @typescript-eslint/unbound-method */
       throw new Error(
         "MediaCapabilitiesProber >>> API_CALL: " + "isTypeSupported not available",
       );

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

@@ -27,6 +27,15 @@ export interface ITypeWithFeatures {
 
 export type ISupportWithFeatures = "" | "Maybe" | "Not Supported" | "Probably";
 
+type IGlobalScopeWithMSMediaKeysFeatures = typeof globalScope & {
+  MSMediaKeys: {
+    isTypeSupportedWithFeatures: (
+      type: string,
+      features: string | null,
+    ) => ISupportWithFeatures;
+  };
+};
+
 /**
  * @returns {Promise}
  */
@@ -37,11 +46,12 @@ function isTypeSupportedWithFeaturesAPIAvailable(): Promise<void> {
         "MediaCapabilitiesProber >>> API_CALL: " + "MSMediaKeys API not available",
       );
     }
-    /* eslint-disable @typescript-eslint/no-explicit-any */
-    /* eslint-disable @typescript-eslint/no-unsafe-member-access */
-    if (!("isTypeSupportedWithFeatures" in (globalScope as any).MSMediaKeys)) {
-      /* eslint-enable @typescript-eslint/no-explicit-any */
-      /* eslint-enable @typescript-eslint/no-unsafe-member-access */
+    if (
+      !(
+        "isTypeSupportedWithFeatures" in
+        (globalScope as IGlobalScopeWithMSMediaKeysFeatures).MSMediaKeys
+      )
+    ) {
       throw new Error(
         "MediaCapabilitiesProber >>> API_CALL: " +
           "isTypeSupportedWithFeatures not available",
@@ -74,17 +84,9 @@ export default function probeTypeWithFeatures(
 
     const features = formatConfig(config);
 
-    /* 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 = (
-      globalScope as any
+      globalScope as IGlobalScopeWithMSMediaKeysFeatures
     ).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 */
 
     function formatSupport(support: ISupportWithFeatures): [ProberStatus] {
       if (support === "") {

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

@@ -27,9 +27,8 @@ export default function probeMatchMedia(
   config: IMediaConfiguration,
 ): Promise<[ProberStatus]> {
   return new Promise((resolve) => {
-    /* eslint-disable @typescript-eslint/unbound-method */
+    // eslint-disable-next-line @typescript-eslint/unbound-method
     if (typeof globalScope.matchMedia !== "function") {
-      /* eslint-enable @typescript-eslint/unbound-method */
       throw new Error(
         "MediaCapabilitiesProber >>> API_CALL: " + "matchMedia not available",
       );

package/src/features/__tests__/add_features.test.ts

@@ -1,10 +1,6 @@
 import { describe, beforeEach, it, expect, vi } from "vitest";
-
-/* eslint-disable @typescript-eslint/no-unsafe-member-access */
-/* 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 type IAddFeatures from "../add_features";
+import type { IFeature } from "../types";
 
 describe("Features - addFeatures", () => {
   beforeEach(() => {
@@ -16,7 +12,8 @@ describe("Features - addFeatures", () => {
     vi.doMock("../features_object", () => ({
       default: feat,
     }));
-    const addFeatures = ((await vi.importActual("../add_features")) as any).default;
+    const addFeatures = (await vi.importActual("../add_features"))
+      .default as typeof IAddFeatures;
 
     expect(() => addFeatures([])).not.toThrow();
   });
@@ -26,15 +23,18 @@ describe("Features - addFeatures", () => {
     vi.doMock("../features_object", () => ({
       default: feat,
     }));
-    const addFeatures = ((await vi.importActual("../add_features")) as any).default;
+    const addFeatures = (await vi.importActual("../add_features"))
+      .default as typeof IAddFeatures;
 
-    expect(() => addFeatures([5])).toThrow(new Error("Unrecognized feature"));
+    expect(() => addFeatures([5 as unknown as IFeature])).toThrow(
+      new Error("Unrecognized feature"),
+    );
     expect(() =>
       addFeatures([
         () => {
           /* noop */
         },
-        {},
+        {} as IFeature,
       ]),
     ).toThrow(new Error("Unrecognized feature"));
   });
@@ -44,7 +44,8 @@ describe("Features - addFeatures", () => {
     vi.doMock("../features_object", () => ({
       default: feat,
     }));
-    const addFeatures = ((await vi.importActual("../add_features")) as any).default;
+    const addFeatures = (await vi.importActual("../add_features"))
+      .default as typeof IAddFeatures;
 
     const fakeFeat1 = vi.fn();
     const fakeFeat2 = vi.fn();

package/src/features/add_features.ts

@@ -22,8 +22,7 @@ import type { IFeature } from "./types";
  * @param {Array.<Object>} featureFuncList
  */
 export default function addFeatures(featureFuncList: IFeature[]): void {
-  for (let i = 0; i < featureFuncList.length; i++) {
-    const addFeature = featureFuncList[i];
+  for (const addFeature of featureFuncList) {
     if (typeof addFeature === "function") {
       addFeature(features);
     } else if (