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

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==",
     );