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

package/src/transports/smooth/isobmff/__tests__/create_boxes.test.ts

@@ -1,10 +1,12 @@
 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 {
+  createFRMABox as ICreateFRMABox,
+  createFreeBox as ICreateFreeBox,
+  createHDLRBox as ICreateHDLRBox,
+  createMDHDBox as ICreateMDHDBox,
+  createSMHDBox as ICreateSMHDBox,
+  createVMHDBox as ICreateVMHDBox,
+} from "../create_boxes";
 
 describe("Smooth - ISOBMFF - boxes creation", () => {
   beforeEach(() => {
@@ -19,8 +21,8 @@ describe("Smooth - ISOBMFF - boxes creation", () => {
       vi.doMock("../../../../parsers/containers/isobmff", () => {
         return { createBox: mockCreateBox };
       });
-      const createVMHDBox = ((await vi.importActual("../create_boxes")) as any)
-        .createVMHDBox;
+      const createVMHDBox = (await vi.importActual("../create_boxes"))
+        .createVMHDBox as typeof ICreateVMHDBox;
       expect(createVMHDBox()).toBe(box);
       expect(mockCreateBox).toHaveBeenCalledTimes(1);
       expect(mockCreateBox).toHaveBeenCalledWith("vmhd", vmhdContent);
@@ -34,8 +36,8 @@ describe("Smooth - ISOBMFF - boxes creation", () => {
       vi.doMock("../../../../parsers/containers/isobmff", () => {
         return { createBox: mockCreateBox };
       });
-      const createFreeBox = ((await vi.importActual("../create_boxes")) as any)
-        .createFreeBox;
+      const createFreeBox = (await vi.importActual("../create_boxes"))
+        .createFreeBox as typeof ICreateFreeBox;
       expect(createFreeBox(8)).toBe(box);
       expect(mockCreateBox).toHaveBeenCalledTimes(1);
       expect(mockCreateBox).toHaveBeenCalledWith("free", new Uint8Array([]));
@@ -51,8 +53,8 @@ describe("Smooth - ISOBMFF - boxes creation", () => {
       vi.doMock("../../../../parsers/containers/isobmff", () => {
         return { createBox: mockCreateBox };
       });
-      const createFreeBox = ((await vi.importActual("../create_boxes")) as any)
-        .createFreeBox;
+      const createFreeBox = (await vi.importActual("../create_boxes"))
+        .createFreeBox as typeof ICreateFreeBox;
       expect(() => createFreeBox(7)).toThrow();
       expect(() => createFreeBox(6)).toThrow();
       expect(() => createFreeBox(5)).toThrow();
@@ -70,8 +72,8 @@ describe("Smooth - ISOBMFF - boxes creation", () => {
       vi.doMock("../../../../parsers/containers/isobmff", () => {
         return { createBox: mockCreateBox };
       });
-      const createFreeBox = ((await vi.importActual("../create_boxes")) as any)
-        .createFreeBox;
+      const createFreeBox = (await vi.importActual("../create_boxes"))
+        .createFreeBox as typeof ICreateFreeBox;
       expect(() => createFreeBox(-1)).toThrow();
       expect(mockCreateBox).not.toHaveBeenCalled();
     });
@@ -82,8 +84,8 @@ describe("Smooth - ISOBMFF - boxes creation", () => {
       vi.doMock("../../../../parsers/containers/isobmff", () => {
         return { createBox: mockCreateBox };
       });
-      const createFreeBox = ((await vi.importActual("../create_boxes")) as any)
-        .createFreeBox;
+      const createFreeBox = (await vi.importActual("../create_boxes"))
+        .createFreeBox as typeof ICreateFreeBox;
       expect(() => createFreeBox(-Infinity)).toThrow();
       expect(() => createFreeBox(+Infinity)).toThrow();
       expect(mockCreateBox).not.toHaveBeenCalled();
@@ -97,8 +99,8 @@ describe("Smooth - ISOBMFF - boxes creation", () => {
       vi.doMock("../../../../parsers/containers/isobmff", () => {
         return { createBox: mockCreateBox };
       });
-      const createHDLRBox = ((await vi.importActual("../create_boxes")) as any)
-        .createHDLRBox;
+      const createHDLRBox = (await vi.importActual("../create_boxes"))
+        .createHDLRBox as typeof ICreateHDLRBox;
       expect(createHDLRBox("audio")).toBe(box);
       expect(mockCreateBox).toHaveBeenCalledTimes(1);
       expect(mockCreateBox).toHaveBeenCalledWith(
@@ -151,8 +153,8 @@ describe("Smooth - ISOBMFF - boxes creation", () => {
       vi.doMock("../../../../parsers/containers/isobmff", () => {
         return { createBox: mockCreateBox };
       });
-      const createHDLRBox = ((await vi.importActual("../create_boxes")) as any)
-        .createHDLRBox;
+      const createHDLRBox = (await vi.importActual("../create_boxes"))
+        .createHDLRBox as typeof ICreateHDLRBox;
       expect(createHDLRBox("video")).toBe(box);
       expect(mockCreateBox).toHaveBeenCalledTimes(1);
       expect(mockCreateBox).toHaveBeenCalledWith(
@@ -205,8 +207,8 @@ describe("Smooth - ISOBMFF - boxes creation", () => {
       vi.doMock("../../../../parsers/containers/isobmff", () => {
         return { createBox: mockCreateBox };
       });
-      const createHDLRBox = ((await vi.importActual("../create_boxes")) as any)
-        .createHDLRBox;
+      const createHDLRBox = (await vi.importActual("../create_boxes"))
+        .createHDLRBox as typeof ICreateHDLRBox;
       expect(createHDLRBox("hint")).toBe(box);
       expect(mockCreateBox).toHaveBeenCalledTimes(1);
       expect(mockCreateBox).toHaveBeenCalledWith(
@@ -256,8 +258,8 @@ describe("Smooth - ISOBMFF - boxes creation", () => {
       vi.doMock("../../../../parsers/containers/isobmff", () => {
         return { createBox: mockCreateBox };
       });
-      const createMDHDBox = ((await vi.importActual("../create_boxes")) as any)
-        .createMDHDBox;
+      const createMDHDBox = (await vi.importActual("../create_boxes"))
+        .createMDHDBox as typeof ICreateMDHDBox;
 
       expect(createMDHDBox(8)).toBe(box);
 
@@ -291,8 +293,8 @@ describe("Smooth - ISOBMFF - boxes creation", () => {
       vi.doMock("../../../../parsers/containers/isobmff", () => {
         return { createBox: mockCreateBox };
       });
-      const createSMHDBox = ((await vi.importActual("../create_boxes")) as any)
-        .createSMHDBox;
+      const createSMHDBox = (await vi.importActual("../create_boxes"))
+        .createSMHDBox as typeof ICreateSMHDBox;
       expect(createSMHDBox()).toBe(box);
       expect(mockCreateBox).toHaveBeenCalledTimes(1);
       expect(mockCreateBox).toHaveBeenCalledWith("smhd", smhdContent);
@@ -311,8 +313,8 @@ describe("Smooth - ISOBMFF - boxes creation", () => {
       vi.doMock("../../../../parsers/containers/isobmff", () => {
         return { createBox: mockCreateBox };
       });
-      const createFRMABox = ((await vi.importActual("../create_boxes")) as any)
-        .createFRMABox;
+      const createFRMABox = (await vi.importActual("../create_boxes"))
+        .createFRMABox as typeof ICreateFRMABox;
       expect(createFRMABox("foo")).toBe(box);
       expect(mockCreateBox).toHaveBeenCalledTimes(1);
       expect(mockCreateBox).toHaveBeenCalledWith("frma", dataFormatToBytes);

package/src/transports/utils/__tests__/check_isobmff_integrity.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 { OtherError as IOtherError } from "../../../errors";
+import type ICheckISOBMFFIntegrity from "../check_isobmff_integrity";
 
 describe("transports utils - checkISOBMFFIntegrity", () => {
   beforeEach(() => {
@@ -16,9 +12,8 @@ describe("transports utils - checkISOBMFFIntegrity", () => {
     vi.doMock("../../../parsers/containers/isobmff", () => ({
       findCompleteBox: mockFindCompleteBox,
     }));
-    const checkISOBMFFIntegrity = (
-      (await vi.importActual("../check_isobmff_integrity")) as any
-    ).default;
+    const checkISOBMFFIntegrity = (await vi.importActual("../check_isobmff_integrity"))
+      .default as typeof ICheckISOBMFFIntegrity;
     const myUint8Array = new Uint8Array([0, 1, 2]);
     expect(() => checkISOBMFFIntegrity(myUint8Array, true)).not.toThrow();
     expect(mockFindCompleteBox).toHaveBeenCalledTimes(2);
@@ -31,9 +26,8 @@ describe("transports utils - checkISOBMFFIntegrity", () => {
     vi.doMock("../../../parsers/containers/isobmff", () => ({
       findCompleteBox: mockFindCompleteBox,
     }));
-    const checkISOBMFFIntegrity = (
-      (await vi.importActual("../check_isobmff_integrity")) as any
-    ).default;
+    const checkISOBMFFIntegrity = (await vi.importActual("../check_isobmff_integrity"))
+      .default as typeof ICheckISOBMFFIntegrity;
     const myUint8Array = new Uint8Array([0, 1, 2]);
     expect(() => checkISOBMFFIntegrity(myUint8Array, false)).not.toThrow();
     expect(mockFindCompleteBox).toHaveBeenCalledTimes(2);
@@ -46,10 +40,10 @@ describe("transports utils - checkISOBMFFIntegrity", () => {
     vi.doMock("../../../parsers/containers/isobmff", () => ({
       findCompleteBox: mockFindCompleteBox,
     }));
-    const OtherError = ((await vi.importActual("../../../errors")) as any).OtherError;
-    const checkISOBMFFIntegrity = (
-      (await vi.importActual("../check_isobmff_integrity")) as any
-    ).default;
+    const OtherError = (await vi.importActual("../../../errors"))
+      .OtherError as typeof IOtherError;
+    const checkISOBMFFIntegrity = (await vi.importActual("../check_isobmff_integrity"))
+      .default as typeof ICheckISOBMFFIntegrity;
     const myUint8Array = new Uint8Array([0, 1, 2]);
     let error: unknown = null;
     try {
@@ -58,10 +52,10 @@ describe("transports utils - checkISOBMFFIntegrity", () => {
       error = e;
     }
     expect(error).toBeInstanceOf(OtherError);
-    expect((error as typeof OtherError).name).toEqual("OtherError");
-    expect((error as typeof OtherError).type).toEqual("OTHER_ERROR");
-    expect((error as typeof OtherError).code).toEqual("INTEGRITY_ERROR");
-    expect((error as typeof OtherError).message).toEqual(
+    expect((error as IOtherError).name).toEqual("OtherError");
+    expect((error as IOtherError).type).toEqual("OTHER_ERROR");
+    expect((error as IOtherError).code).toEqual("INTEGRITY_ERROR");
+    expect((error as IOtherError).message).toEqual(
       "INTEGRITY_ERROR: Incomplete `ftyp` box",
     );
   });
@@ -71,10 +65,10 @@ describe("transports utils - checkISOBMFFIntegrity", () => {
     vi.doMock("../../../parsers/containers/isobmff", () => ({
       findCompleteBox: mockFindCompleteBox,
     }));
-    const OtherError = ((await vi.importActual("../../../errors")) as any).OtherError;
-    const checkISOBMFFIntegrity = (
-      (await vi.importActual("../check_isobmff_integrity")) as any
-    ).default;
+    const OtherError = (await vi.importActual("../../../errors"))
+      .OtherError as typeof IOtherError;
+    const checkISOBMFFIntegrity = (await vi.importActual("../check_isobmff_integrity"))
+      .default as typeof ICheckISOBMFFIntegrity;
     const myUint8Array = new Uint8Array([0, 1, 2]);
     let error: unknown = null;
     try {
@@ -83,10 +77,10 @@ describe("transports utils - checkISOBMFFIntegrity", () => {
       error = e;
     }
     expect(error).toBeInstanceOf(OtherError);
-    expect((error as typeof OtherError).name).toEqual("OtherError");
-    expect((error as typeof OtherError).type).toEqual("OTHER_ERROR");
-    expect((error as typeof OtherError).code).toEqual("INTEGRITY_ERROR");
-    expect((error as typeof OtherError).message).toEqual(
+    expect((error as IOtherError).name).toEqual("OtherError");
+    expect((error as IOtherError).type).toEqual("OTHER_ERROR");
+    expect((error as IOtherError).code).toEqual("INTEGRITY_ERROR");
+    expect((error as IOtherError).message).toEqual(
       "INTEGRITY_ERROR: Incomplete `moov` box",
     );
   });
@@ -96,10 +90,10 @@ describe("transports utils - checkISOBMFFIntegrity", () => {
     vi.doMock("../../../parsers/containers/isobmff", () => ({
       findCompleteBox: mockFindCompleteBox,
     }));
-    const OtherError = ((await vi.importActual("../../../errors")) as any).OtherError;
-    const checkISOBMFFIntegrity = (
-      (await vi.importActual("../check_isobmff_integrity")) as any
-    ).default;
+    const OtherError = (await vi.importActual("../../../errors"))
+      .OtherError as typeof IOtherError;
+    const checkISOBMFFIntegrity = (await vi.importActual("../check_isobmff_integrity"))
+      .default as typeof ICheckISOBMFFIntegrity;
     const myUint8Array = new Uint8Array([0, 1, 2]);
     let error: unknown = null;
     try {
@@ -108,10 +102,10 @@ describe("transports utils - checkISOBMFFIntegrity", () => {
       error = e;
     }
     expect(error).toBeInstanceOf(OtherError);
-    expect((error as typeof OtherError).name).toEqual("OtherError");
-    expect((error as typeof OtherError).type).toEqual("OTHER_ERROR");
-    expect((error as typeof OtherError).code).toEqual("INTEGRITY_ERROR");
-    expect((error as typeof OtherError).message).toEqual(
+    expect((error as IOtherError).name).toEqual("OtherError");
+    expect((error as IOtherError).type).toEqual("OTHER_ERROR");
+    expect((error as IOtherError).code).toEqual("INTEGRITY_ERROR");
+    expect((error as IOtherError).message).toEqual(
       "INTEGRITY_ERROR: Incomplete `moof` box",
     );
   });
@@ -121,10 +115,10 @@ describe("transports utils - checkISOBMFFIntegrity", () => {
     vi.doMock("../../../parsers/containers/isobmff", () => ({
       findCompleteBox: mockFindCompleteBox,
     }));
-    const OtherError = ((await vi.importActual("../../../errors")) as any).OtherError;
-    const checkISOBMFFIntegrity = (
-      (await vi.importActual("../check_isobmff_integrity")) as any
-    ).default;
+    const OtherError = (await vi.importActual("../../../errors"))
+      .OtherError as typeof IOtherError;
+    const checkISOBMFFIntegrity = (await vi.importActual("../check_isobmff_integrity"))
+      .default as typeof ICheckISOBMFFIntegrity;
     const myUint8Array = new Uint8Array([0, 1, 2]);
     let error: unknown = null;
     try {
@@ -133,10 +127,10 @@ describe("transports utils - checkISOBMFFIntegrity", () => {
       error = e;
     }
     expect(error).toBeInstanceOf(OtherError);
-    expect((error as typeof OtherError).name).toEqual("OtherError");
-    expect((error as typeof OtherError).type).toEqual("OTHER_ERROR");
-    expect((error as typeof OtherError).code).toEqual("INTEGRITY_ERROR");
-    expect((error as typeof OtherError).message).toEqual(
+    expect((error as IOtherError).name).toEqual("OtherError");
+    expect((error as IOtherError).type).toEqual("OTHER_ERROR");
+    expect((error as IOtherError).code).toEqual("INTEGRITY_ERROR");
+    expect((error as IOtherError).message).toEqual(
       "INTEGRITY_ERROR: Incomplete `mdat` box",
     );
   });

package/src/utils/__tests__/array_find.test.ts

@@ -1,23 +1,20 @@
 import { describe, beforeEach, afterEach, it, expect, vi } from "vitest";
 import arrayFind from "../array_find";
 
-/* eslint-disable no-invalid-this */
-/* eslint-disable no-restricted-properties */
-/* eslint-disable @typescript-eslint/no-unsafe-assignment */
-/* eslint-disable @typescript-eslint/no-unsafe-member-access */
-/* eslint-disable @typescript-eslint/no-restricted-types */
-
-/* eslint-disable @typescript-eslint/unbound-method */
-const initialArrayFind = (Array.prototype as { find: unknown }).find;
-/* eslint-enable @typescript-eslint/unbound-method */
+// eslint-disable-next-line no-restricted-properties, @typescript-eslint/unbound-method
+const initialArrayFind = Array.prototype.find;
 
 describe("utils - arrayFind", () => {
   beforeEach(() => {
-    (Array.prototype as { find: unknown }).find = undefined;
+    // @ts-expect-error: Remove temporarily default `find` implementation
+    // to rely on our own instead.
+    // eslint-disable-next-line no-restricted-properties
+    Array.prototype.find = undefined;
   });
 
   afterEach(() => {
-    (Array.prototype as { find: unknown }).find = initialArrayFind;
+    // eslint-disable-next-line no-restricted-properties
+    Array.prototype.find = initialArrayFind;
   });
 
   it("should return undefined for an empty array", () => {
@@ -73,6 +70,7 @@ describe("utils - arrayFind", () => {
     arrayFind(
       arr,
       function (this: unknown) {
+        // eslint-disable-next-line no-invalid-this
         expect(this).toBe(context);
         return false;
       },
@@ -82,7 +80,8 @@ describe("utils - arrayFind", () => {
 
   if (typeof initialArrayFind === "function") {
     it("should call the original array.find function if it exists", () => {
-      (Array.prototype as { find: unknown }).find = initialArrayFind;
+      // eslint-disable-next-line no-restricted-properties
+      Array.prototype.find = initialArrayFind;
       const obj1 = {};
       const obj2 = {};
       const context = {};
@@ -96,6 +95,7 @@ describe("utils - arrayFind", () => {
         index: number,
         cArr: unknown[],
       ): boolean {
+        // eslint-disable-next-line no-invalid-this
         expect(this).toBe(context);
         expect(index).toBe(currentIndex++);
         expect(cArr).toBe(arr);

package/src/utils/__tests__/array_find_index.test.ts

@@ -1,23 +1,21 @@
 import { describe, beforeEach, afterEach, it, expect, vi } from "vitest";
 import arrayFindIndex from "../array_find_index";
 
-/* eslint-disable no-invalid-this */
-/* eslint-disable no-restricted-properties */
-/* eslint-disable @typescript-eslint/no-unsafe-assignment */
-/* eslint-disable @typescript-eslint/no-unsafe-member-access */
-/* eslint-disable @typescript-eslint/no-restricted-types */
-
-/* eslint-disable @typescript-eslint/unbound-method */
-const initialArrayFindIndex = (Array.prototype as { findIndex: unknown }).findIndex;
-/* eslint-enable @typescript-eslint/unbound-method */
+// eslint-disable-next-line @typescript-eslint/unbound-method
+// eslint-disable-next-line no-restricted-properties
+const initialArrayFindIndex = Array.prototype.findIndex;
 
 describe("utils - arrayFindIndex", () => {
   beforeEach(() => {
-    (Array.prototype as { findIndex: unknown }).findIndex = undefined;
+    // @ts-expect-error: Remove temporarily default `findIndex` implementation
+    // to rely on our own instead.
+    // eslint-disable-next-line no-restricted-properties
+    Array.prototype.findIndex = undefined;
   });
 
   afterEach(() => {
-    (Array.prototype as { findIndex: unknown }).findIndex = initialArrayFindIndex;
+    // eslint-disable-next-line no-restricted-properties
+    Array.prototype.findIndex = initialArrayFindIndex;
   });
 
   it("should return -1 for an empty array", () => {
@@ -73,6 +71,7 @@ describe("utils - arrayFindIndex", () => {
     arrayFindIndex(
       arr,
       function (this: unknown) {
+        // eslint-disable-next-line no-invalid-this
         expect(this).toBe(context);
         return false;
       },
@@ -82,7 +81,8 @@ describe("utils - arrayFindIndex", () => {
 
   if (typeof initialArrayFindIndex === "function") {
     it("should call the original array.findIndex function if it exists", () => {
-      (Array.prototype as { findIndex: unknown }).findIndex = initialArrayFindIndex;
+      // eslint-disable-next-line no-restricted-properties
+      Array.prototype.findIndex = initialArrayFindIndex;
       const obj1 = {};
       const obj2 = {};
       const context = {};
@@ -96,6 +96,7 @@ describe("utils - arrayFindIndex", () => {
         index: number,
         cArr: unknown[],
       ): boolean {
+        // eslint-disable-next-line no-invalid-this
         expect(this).toBe(context);
         expect(index).toBe(currentIndex++);
         expect(cArr).toBe(arr);

package/src/utils/__tests__/array_includes.test.ts

@@ -1,19 +1,19 @@
 import { describe, beforeEach, afterEach, it, expect } from "vitest";
 import arrayIncludes from "../array_includes";
 
-/* eslint-disable @typescript-eslint/no-unsafe-member-access */
-/* eslint-disable no-restricted-properties */
-
-/* eslint-disable @typescript-eslint/unbound-method */
+// eslint-disable-next-line no-restricted-properties, @typescript-eslint/unbound-method
 const initialArrayIncludes = Array.prototype.includes;
-/* eslint-enable @typescript-eslint/unbound-method */
+
 describe("utils - array-includes", () => {
   beforeEach(() => {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    (Array.prototype as any).includes = undefined;
+    // @ts-expect-error: We're setting `includes` to `undefined` to
+    // specifically test our own implementation
+    // eslint-disable-next-line no-restricted-properties
+    Array.prototype.includes = undefined;
   });
 
   afterEach(() => {
+    // eslint-disable-next-line no-restricted-properties
     Array.prototype.includes = initialArrayIncludes;
   });
 

package/src/utils/__tests__/assert.test.ts

@@ -1,12 +1,9 @@
 import { describe, it, expect } from "vitest";
 import assert, { assertInterface, assertUnreachable, AssertionError } from "../assert";
 
-/* eslint-disable @typescript-eslint/no-unsafe-assignment */
-/* eslint-disable @typescript-eslint/no-unsafe-member-access */
-
 describe("utils - assert", () => {
   it("should throw an error if the assertion is false", () => {
-    let error;
+    let error: unknown;
     try {
       assert(false);
     } catch (e) {
@@ -24,7 +21,7 @@ describe("utils - assert", () => {
 
   it("should be able to take a message argument", () => {
     const myMessage = "foo bar\n\r";
-    let error;
+    let error: unknown;
     try {
       assert(false, myMessage);
     } catch (e) {
@@ -47,7 +44,7 @@ describe("utils - assert", () => {
 
 describe("utils - assertInterface", () => {
   it("should throw if undefined or null is given", () => {
-    let error;
+    let error: unknown;
     const nameOfMyObj = "toto titi";
 
     const objIface = {
@@ -88,16 +85,16 @@ describe("utils - assertInterface", () => {
   });
 
   it("should throw if the concerned interface is not respected", () => {
-    let error;
+    let error: unknown;
     const nameOfMyObj = "toto titi";
     const myObj = {
       a: 45,
       b: {
         c: "toto",
       },
-      /* eslint-disable no-empty,@typescript-eslint/no-empty-function */
-      d: () => {},
-      /* eslint-enable no-empty,@typescript-eslint/no-empty-function */
+      d: () => {
+        /* noop */
+      },
       e: true,
     };
 
@@ -114,9 +111,7 @@ describe("utils - assertInterface", () => {
     } catch (e) {
       error = e;
     }
-    /* eslint-disable @typescript-eslint/no-unused-expressions */
     expect(error).toBeDefined();
-    /* eslint-enable @typescript-eslint/no-unused-expressions */
 
     expect(error).toBeInstanceOf(Error);
 
@@ -129,15 +124,15 @@ describe("utils - assertInterface", () => {
   });
 
   it("should name the interface 'object' if no name is specified", () => {
-    let error;
+    let error: unknown;
     const myObj = {
       a: 45,
       b: {
         c: "toto",
       },
-      /* eslint-disable no-empty,@typescript-eslint/no-empty-function */
-      d: () => {},
-      /* eslint-enable no-empty,@typescript-eslint/no-empty-function */
+      d: () => {
+        /* noop */
+      },
       e: true,
     };
 
@@ -171,9 +166,9 @@ describe("utils - assertInterface", () => {
       b: {
         c: "toto",
       },
-      /* eslint-disable no-empty,@typescript-eslint/no-empty-function */
-      d: () => {},
-      /* eslint-enable no-empty,@typescript-eslint/no-empty-function */
+      d: () => {
+        /* noop */
+      },
       e: true,
     };
 
@@ -194,14 +189,13 @@ describe("utils - assertInterface", () => {
       b: {
         c: "toto",
       },
-      /* eslint-disable no-empty,@typescript-eslint/no-empty-function */
-      d: () => {},
-      /* eslint-enable no-empty,@typescript-eslint/no-empty-function */
+      d: () => {
+        /* noop */
+      },
       e: true,
     };
 
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    (Object.prototype as any).f = "number";
+    (Object.prototype as { f?: string }).f = "number";
 
     const objIface = {
       a: "number",
@@ -225,7 +219,7 @@ describe("utils - AssertionError", () => {
 
 describe("utils - assertUnreachable", () => {
   it("should throw an error if the function is called", () => {
-    let error;
+    let error: unknown;
     try {
       assertUnreachable(4 as never);
     } catch (e: unknown) {

package/src/utils/__tests__/base64.test.ts

@@ -1,12 +1,10 @@
 import { describe, beforeEach, it, expect, vi, afterEach } from "vitest";
+import type {
+  base64ToBytes as IBase64ToBytes,
+  bytesToBase64 as IBytesToBase64,
+} from "../base64";
 import globalScope from "../global_scope";
 
-/* 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 */
-
 /** Every chars defined in base64. */
 const CHARS = [
   "A",
@@ -88,13 +86,15 @@ describe("base64ToBytes", () => {
   });
 
   it("should return an empty Uint8Array for an empty string", async () => {
-    const base64ToBytes = ((await vi.importActual("../base64")) as any).base64ToBytes;
+    const base64ToBytes = (await vi.importActual("../base64"))
+      .base64ToBytes as typeof IBase64ToBytes;
     expect(base64ToBytes("")).toEqual(new Uint8Array([]));
     expect(logWarn).not.toHaveBeenCalled();
   });
 
   it("should convert a base64 to an Uint8Array", async () => {
-    const base64ToBytes = ((await vi.importActual("../base64")) as any).base64ToBytes;
+    const base64ToBytes = (await vi.importActual("../base64"))
+      .base64ToBytes as typeof IBase64ToBytes;
     expect(base64ToBytes("woDCge+/vg==")).toEqual(
       new Uint8Array([194, 128, 194, 129, 239, 191, 190]),
     );
@@ -112,7 +112,8 @@ describe("base64ToBytes", () => {
     );
     expect(logWarn).not.toHaveBeenCalled();
 
-    const bytesToBase64 = ((await vi.importActual("../base64")) as any).bytesToBase64;
+    const bytesToBase64 = (await vi.importActual("../base64"))
+      .bytesToBase64 as typeof IBytesToBase64;
 
     for (let i = 0; i < CHARS.length; i++) {
       const char1 = CHARS[i];
@@ -131,7 +132,8 @@ describe("base64ToBytes", () => {
   });
 
   it("should convert a non-padded base64 to an Uint8Array", async () => {
-    const base64ToBytes = ((await vi.importActual("../base64")) as any).base64ToBytes;
+    const base64ToBytes = (await vi.importActual("../base64"))
+      .base64ToBytes as typeof IBase64ToBytes;
     expect(base64ToBytes("woDCge+/vg")).toEqual(
       new Uint8Array([194, 128, 194, 129, 239, 191, 190]),
     );
@@ -151,7 +153,8 @@ describe("base64ToBytes", () => {
   });
 
   it("should fail on invalid data", async () => {
-    const base64ToBytes = ((await vi.importActual("../base64")) as any).base64ToBytes;
+    const base64ToBytes = (await vi.importActual("../base64"))
+      .base64ToBytes as typeof IBase64ToBytes;
     expect(() => base64ToBytes("woD=Cge+/vg=")).toThrowError(
       "Unable to parse base64 string.",
     );
@@ -175,13 +178,15 @@ describe("bytesToBase64", () => {
   });
 
   it("should return an empty string for an empty Uint8Array", async () => {
-    const bytesToBase64 = ((await vi.importActual("../base64")) as any).bytesToBase64;
+    const bytesToBase64 = (await vi.importActual("../base64"))
+      .bytesToBase64 as typeof IBytesToBase64;
     expect(bytesToBase64(new Uint8Array([]))).toEqual("");
     expect(logWarn).not.toHaveBeenCalled();
   });
 
   it("should convert a base64 to an Uint8Array", async () => {
-    const bytesToBase64 = ((await vi.importActual("../base64")) as any).bytesToBase64;
+    const bytesToBase64 = (await vi.importActual("../base64"))
+      .bytesToBase64 as typeof IBytesToBase64;
     expect(bytesToBase64(new Uint8Array([194, 128, 194, 129, 239, 191, 190]))).toEqual(
       "woDCge+/vg==",
     );