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

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

@@ -1,11 +1,6 @@
 import { describe, it, expect } from "vitest";
 import EventEmitter from "../event_emitter";
 
-/* eslint-disable @typescript-eslint/no-unsafe-member-access */
-/* eslint-disable @typescript-eslint/no-unsafe-call */
-/* eslint-disable @typescript-eslint/no-unsafe-return */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-
 describe("utils - EventEmitter", () => {
   it("should be able to call synchronously a callback on a given event", () => {
     const eventEmitter = new EventEmitter<{
@@ -18,9 +13,17 @@ describe("utils - EventEmitter", () => {
     });
 
     expect(wasCalled).toEqual(0);
-    (eventEmitter as any).trigger("something", undefined);
+    (
+      eventEmitter as EventEmitter<unknown> & {
+        trigger(evtName: string, payload: unknown): void;
+      }
+    ).trigger("something", undefined);
     expect(wasCalled).toEqual(1);
-    (eventEmitter as any).trigger("nope", undefined);
+    (
+      eventEmitter as EventEmitter<unknown> & {
+        trigger(evtName: string, payload: unknown): void;
+      }
+    ).trigger("nope", undefined);
     expect(wasCalled).toEqual(1);
     eventEmitter.removeEventListener();
   });
@@ -46,33 +49,69 @@ describe("utils - EventEmitter", () => {
     expect(wasCalledWithString).toEqual(0);
     expect(wasCalledWithObject).toEqual(0);
 
-    (eventEmitter as any).trigger("something", undefined);
+    (
+      eventEmitter as EventEmitter<unknown> & {
+        trigger(evtName: string, payload: unknown): void;
+      }
+    ).trigger("something", undefined);
     expect(wasCalledWithString).toEqual(0);
     expect(wasCalledWithObject).toEqual(0);
 
-    (eventEmitter as any).trigger("something", "a");
+    (
+      eventEmitter as EventEmitter<unknown> & {
+        trigger(evtName: string, payload: unknown): void;
+      }
+    ).trigger("something", "a");
     expect(wasCalledWithString).toEqual(1);
     expect(wasCalledWithObject).toEqual(0);
 
-    (eventEmitter as any).trigger("nope", undefined);
+    (
+      eventEmitter as EventEmitter<unknown> & {
+        trigger(evtName: string, payload: unknown): void;
+      }
+    ).trigger("nope", undefined);
     expect(wasCalledWithString).toEqual(1);
     expect(wasCalledWithObject).toEqual(0);
 
-    (eventEmitter as any).trigger("nope", undefined);
+    (
+      eventEmitter as EventEmitter<unknown> & {
+        trigger(evtName: string, payload: unknown): void;
+      }
+    ).trigger("nope", undefined);
     expect(wasCalledWithString).toEqual(1);
     expect(wasCalledWithObject).toEqual(0);
 
-    (eventEmitter as any).trigger("something", { a: "b" });
+    (
+      eventEmitter as EventEmitter<unknown> & {
+        trigger(evtName: string, payload: unknown): void;
+      }
+    ).trigger("something", { a: "b" });
     expect(wasCalledWithString).toEqual(1);
     expect(wasCalledWithObject).toEqual(1);
 
-    (eventEmitter as any).trigger("something", "a");
-    (eventEmitter as any).trigger("something", "a");
-    (eventEmitter as any).trigger("something", "a");
+    (
+      eventEmitter as EventEmitter<unknown> & {
+        trigger(evtName: string, payload: unknown): void;
+      }
+    ).trigger("something", "a");
+    (
+      eventEmitter as EventEmitter<unknown> & {
+        trigger(evtName: string, payload: unknown): void;
+      }
+    ).trigger("something", "a");
+    (
+      eventEmitter as EventEmitter<unknown> & {
+        trigger(evtName: string, payload: unknown): void;
+      }
+    ).trigger("something", "a");
     expect(wasCalledWithString).toEqual(4);
     expect(wasCalledWithObject).toEqual(1);
 
-    (eventEmitter as any).trigger("nope", undefined);
+    (
+      eventEmitter as EventEmitter<unknown> & {
+        trigger(evtName: string, payload: unknown): void;
+      }
+    ).trigger("nope", undefined);
     expect(wasCalledWithString).toEqual(4);
     expect(wasCalledWithObject).toEqual(1);
     eventEmitter.removeEventListener();
@@ -98,38 +137,78 @@ describe("utils - EventEmitter", () => {
     expect(wasCalledWithString).toEqual(0);
     expect(wasCalledWithObject).toEqual(0);
 
-    (eventEmitter as any).trigger("something", undefined);
+    (
+      eventEmitter as EventEmitter<unknown> & {
+        trigger(evtName: string, payload: unknown): void;
+      }
+    ).trigger("something", undefined);
     expect(wasCalledWithString).toEqual(0);
     expect(wasCalledWithObject).toEqual(0);
 
-    (eventEmitter as any).trigger("something", "a");
+    (
+      eventEmitter as EventEmitter<unknown> & {
+        trigger(evtName: string, payload: unknown): void;
+      }
+    ).trigger("something", "a");
     expect(wasCalledWithString).toEqual(1);
     expect(wasCalledWithObject).toEqual(0);
 
-    (eventEmitter as any).trigger("nope", undefined);
+    (
+      eventEmitter as EventEmitter<unknown> & {
+        trigger(evtName: string, payload: unknown): void;
+      }
+    ).trigger("nope", undefined);
     expect(wasCalledWithString).toEqual(1);
     expect(wasCalledWithObject).toEqual(0);
 
-    (eventEmitter as any).trigger("nope", "a");
+    (
+      eventEmitter as EventEmitter<unknown> & {
+        trigger(evtName: string, payload: unknown): void;
+      }
+    ).trigger("nope", "a");
     expect(wasCalledWithString).toEqual(2);
     expect(wasCalledWithObject).toEqual(0);
 
-    (eventEmitter as any).trigger("something", { a: "b" });
+    (
+      eventEmitter as EventEmitter<unknown> & {
+        trigger(evtName: string, payload: unknown): void;
+      }
+    ).trigger("something", { a: "b" });
     expect(wasCalledWithString).toEqual(2);
     expect(wasCalledWithObject).toEqual(1);
 
     eventEmitter.removeEventListener("something", callback);
-    (eventEmitter as any).trigger("something", "a");
-    (eventEmitter as any).trigger("something", "a");
-    (eventEmitter as any).trigger("something", "a");
+    (
+      eventEmitter as EventEmitter<unknown> & {
+        trigger(evtName: string, payload: unknown): void;
+      }
+    ).trigger("something", "a");
+    (
+      eventEmitter as EventEmitter<unknown> & {
+        trigger(evtName: string, payload: unknown): void;
+      }
+    ).trigger("something", "a");
+    (
+      eventEmitter as EventEmitter<unknown> & {
+        trigger(evtName: string, payload: unknown): void;
+      }
+    ).trigger("something", "a");
     expect(wasCalledWithString).toEqual(2);
     expect(wasCalledWithObject).toEqual(1);
 
-    (eventEmitter as any).trigger("nope", undefined);
+    (
+      eventEmitter as EventEmitter<unknown> & {
+        trigger(evtName: string, payload: unknown): void;
+      }
+    ).trigger("nope", undefined);
     expect(wasCalledWithString).toEqual(2);
     expect(wasCalledWithObject).toEqual(1);
 
-    (eventEmitter as any).trigger("nope", "a");
+    (
+      eventEmitter as EventEmitter<unknown> & {
+        trigger(evtName: string, payload: unknown): void;
+      }
+    ).trigger("nope", "a");
     expect(wasCalledWithString).toEqual(3);
     expect(wasCalledWithObject).toEqual(1);
     eventEmitter.removeEventListener();
@@ -179,7 +258,11 @@ describe("utils - EventEmitter", () => {
     expect(wasCalledWithString3).toEqual(0);
     expect(wasCalledWithObject3).toEqual(0);
 
-    (eventEmitter as any).trigger("something", undefined);
+    (
+      eventEmitter as EventEmitter<unknown> & {
+        trigger(evtName: string, payload: unknown): void;
+      }
+    ).trigger("something", undefined);
     expect(wasCalledWithString1).toEqual(0);
     expect(wasCalledWithObject1).toEqual(0);
     expect(wasCalledWithString2).toEqual(0);
@@ -187,7 +270,11 @@ describe("utils - EventEmitter", () => {
     expect(wasCalledWithString3).toEqual(0);
     expect(wasCalledWithObject3).toEqual(0);
 
-    (eventEmitter as any).trigger("something", "a");
+    (
+      eventEmitter as EventEmitter<unknown> & {
+        trigger(evtName: string, payload: unknown): void;
+      }
+    ).trigger("something", "a");
     expect(wasCalledWithString1).toEqual(1);
     expect(wasCalledWithObject1).toEqual(0);
     expect(wasCalledWithString2).toEqual(1);
@@ -203,7 +290,11 @@ describe("utils - EventEmitter", () => {
     expect(wasCalledWithString3).toEqual(0);
     expect(wasCalledWithObject3).toEqual(0);
 
-    (eventEmitter as any).trigger("something", "a");
+    (
+      eventEmitter as EventEmitter<unknown> & {
+        trigger(evtName: string, payload: unknown): void;
+      }
+    ).trigger("something", "a");
     expect(wasCalledWithString1).toEqual(2);
     expect(wasCalledWithObject1).toEqual(0);
     expect(wasCalledWithString2).toEqual(2);
@@ -211,7 +302,11 @@ describe("utils - EventEmitter", () => {
     expect(wasCalledWithString3).toEqual(1);
     expect(wasCalledWithObject3).toEqual(0);
 
-    (eventEmitter as any).trigger("nope", undefined);
+    (
+      eventEmitter as EventEmitter<unknown> & {
+        trigger(evtName: string, payload: unknown): void;
+      }
+    ).trigger("nope", undefined);
     expect(wasCalledWithString1).toEqual(2);
     expect(wasCalledWithObject1).toEqual(0);
     expect(wasCalledWithString2).toEqual(2);
@@ -219,7 +314,11 @@ describe("utils - EventEmitter", () => {
     expect(wasCalledWithString3).toEqual(1);
     expect(wasCalledWithObject3).toEqual(0);
 
-    (eventEmitter as any).trigger("nope", "a");
+    (
+      eventEmitter as EventEmitter<unknown> & {
+        trigger(evtName: string, payload: unknown): void;
+      }
+    ).trigger("nope", "a");
     expect(wasCalledWithString1).toEqual(3);
     expect(wasCalledWithObject1).toEqual(0);
     expect(wasCalledWithString2).toEqual(2);
@@ -227,7 +326,11 @@ describe("utils - EventEmitter", () => {
     expect(wasCalledWithString3).toEqual(2);
     expect(wasCalledWithObject3).toEqual(0);
 
-    (eventEmitter as any).trigger("something", { a: "b" });
+    (
+      eventEmitter as EventEmitter<unknown> & {
+        trigger(evtName: string, payload: unknown): void;
+      }
+    ).trigger("something", { a: "b" });
     expect(wasCalledWithString1).toEqual(3);
     expect(wasCalledWithObject1).toEqual(1);
     expect(wasCalledWithString2).toEqual(2);
@@ -243,7 +346,11 @@ describe("utils - EventEmitter", () => {
     expect(wasCalledWithString3).toEqual(2);
     expect(wasCalledWithObject3).toEqual(1);
 
-    (eventEmitter as any).trigger("something", { a: "b" });
+    (
+      eventEmitter as EventEmitter<unknown> & {
+        trigger(evtName: string, payload: unknown): void;
+      }
+    ).trigger("something", { a: "b" });
     expect(wasCalledWithString1).toEqual(3);
     expect(wasCalledWithObject1).toEqual(2);
     expect(wasCalledWithString2).toEqual(2);
@@ -251,7 +358,11 @@ describe("utils - EventEmitter", () => {
     expect(wasCalledWithString3).toEqual(2);
     expect(wasCalledWithObject3).toEqual(2);
 
-    (eventEmitter as any).trigger("nope", { a: "b" });
+    (
+      eventEmitter as EventEmitter<unknown> & {
+        trigger(evtName: string, payload: unknown): void;
+      }
+    ).trigger("nope", { a: "b" });
     expect(wasCalledWithString1).toEqual(3);
     expect(wasCalledWithObject1).toEqual(3);
     expect(wasCalledWithString2).toEqual(2);
@@ -305,7 +416,11 @@ describe("utils - EventEmitter", () => {
     expect(wasCalledWithString3).toEqual(0);
     expect(wasCalledWithObject3).toEqual(0);
 
-    (eventEmitter as any).trigger("something", undefined);
+    (
+      eventEmitter as EventEmitter<unknown> & {
+        trigger(evtName: string, payload: unknown): void;
+      }
+    ).trigger("something", undefined);
     expect(wasCalledWithString1).toEqual(0);
     expect(wasCalledWithObject1).toEqual(0);
     expect(wasCalledWithString2).toEqual(0);
@@ -313,7 +428,11 @@ describe("utils - EventEmitter", () => {
     expect(wasCalledWithString3).toEqual(0);
     expect(wasCalledWithObject3).toEqual(0);
 
-    (eventEmitter as any).trigger("something", "a");
+    (
+      eventEmitter as EventEmitter<unknown> & {
+        trigger(evtName: string, payload: unknown): void;
+      }
+    ).trigger("something", "a");
     expect(wasCalledWithString1).toEqual(1);
     expect(wasCalledWithObject1).toEqual(0);
     expect(wasCalledWithString2).toEqual(1);
@@ -329,7 +448,11 @@ describe("utils - EventEmitter", () => {
     expect(wasCalledWithString3).toEqual(0);
     expect(wasCalledWithObject3).toEqual(0);
 
-    (eventEmitter as any).trigger("something", "a");
+    (
+      eventEmitter as EventEmitter<unknown> & {
+        trigger(evtName: string, payload: unknown): void;
+      }
+    ).trigger("something", "a");
     expect(wasCalledWithString1).toEqual(2);
     expect(wasCalledWithObject1).toEqual(0);
     expect(wasCalledWithString2).toEqual(2);
@@ -337,7 +460,11 @@ describe("utils - EventEmitter", () => {
     expect(wasCalledWithString3).toEqual(1);
     expect(wasCalledWithObject3).toEqual(0);
 
-    (eventEmitter as any).trigger("nope", undefined);
+    (
+      eventEmitter as EventEmitter<unknown> & {
+        trigger(evtName: string, payload: unknown): void;
+      }
+    ).trigger("nope", undefined);
     expect(wasCalledWithString1).toEqual(2);
     expect(wasCalledWithObject1).toEqual(0);
     expect(wasCalledWithString2).toEqual(2);
@@ -345,7 +472,11 @@ describe("utils - EventEmitter", () => {
     expect(wasCalledWithString3).toEqual(1);
     expect(wasCalledWithObject3).toEqual(0);
 
-    (eventEmitter as any).trigger("nope", "a");
+    (
+      eventEmitter as EventEmitter<unknown> & {
+        trigger(evtName: string, payload: unknown): void;
+      }
+    ).trigger("nope", "a");
     expect(wasCalledWithString1).toEqual(3);
     expect(wasCalledWithObject1).toEqual(0);
     expect(wasCalledWithString2).toEqual(2);
@@ -353,7 +484,11 @@ describe("utils - EventEmitter", () => {
     expect(wasCalledWithString3).toEqual(2);
     expect(wasCalledWithObject3).toEqual(0);
 
-    (eventEmitter as any).trigger("something", { a: "b" });
+    (
+      eventEmitter as EventEmitter<unknown> & {
+        trigger(evtName: string, payload: unknown): void;
+      }
+    ).trigger("something", { a: "b" });
     expect(wasCalledWithString1).toEqual(3);
     expect(wasCalledWithObject1).toEqual(1);
     expect(wasCalledWithString2).toEqual(2);
@@ -369,7 +504,11 @@ describe("utils - EventEmitter", () => {
     expect(wasCalledWithString3).toEqual(2);
     expect(wasCalledWithObject3).toEqual(1);
 
-    (eventEmitter as any).trigger("something", { a: "b" });
+    (
+      eventEmitter as EventEmitter<unknown> & {
+        trigger(evtName: string, payload: unknown): void;
+      }
+    ).trigger("something", { a: "b" });
     expect(wasCalledWithString1).toEqual(3);
     expect(wasCalledWithObject1).toEqual(1);
     expect(wasCalledWithString2).toEqual(2);
@@ -377,7 +516,11 @@ describe("utils - EventEmitter", () => {
     expect(wasCalledWithString3).toEqual(2);
     expect(wasCalledWithObject3).toEqual(1);
 
-    (eventEmitter as any).trigger("nope", { a: "b" });
+    (
+      eventEmitter as EventEmitter<unknown> & {
+        trigger(evtName: string, payload: unknown): void;
+      }
+    ).trigger("nope", { a: "b" });
     expect(wasCalledWithString1).toEqual(3);
     expect(wasCalledWithObject1).toEqual(2);
     expect(wasCalledWithString2).toEqual(2);
@@ -431,7 +574,11 @@ describe("utils - EventEmitter", () => {
     expect(wasCalledWithString3).toEqual(0);
     expect(wasCalledWithObject3).toEqual(0);
 
-    (eventEmitter as any).trigger("something", undefined);
+    (
+      eventEmitter as EventEmitter<unknown> & {
+        trigger(evtName: string, payload: unknown): void;
+      }
+    ).trigger("something", undefined);
     expect(wasCalledWithString1).toEqual(0);
     expect(wasCalledWithObject1).toEqual(0);
     expect(wasCalledWithString2).toEqual(0);
@@ -439,7 +586,11 @@ describe("utils - EventEmitter", () => {
     expect(wasCalledWithString3).toEqual(0);
     expect(wasCalledWithObject3).toEqual(0);
 
-    (eventEmitter as any).trigger("something", "a");
+    (
+      eventEmitter as EventEmitter<unknown> & {
+        trigger(evtName: string, payload: unknown): void;
+      }
+    ).trigger("something", "a");
     expect(wasCalledWithString1).toEqual(1);
     expect(wasCalledWithObject1).toEqual(0);
     expect(wasCalledWithString2).toEqual(1);
@@ -455,7 +606,11 @@ describe("utils - EventEmitter", () => {
     expect(wasCalledWithString3).toEqual(0);
     expect(wasCalledWithObject3).toEqual(0);
 
-    (eventEmitter as any).trigger("something", "a");
+    (
+      eventEmitter as EventEmitter<unknown> & {
+        trigger(evtName: string, payload: unknown): void;
+      }
+    ).trigger("something", "a");
     expect(wasCalledWithString1).toEqual(2);
     expect(wasCalledWithObject1).toEqual(0);
     expect(wasCalledWithString2).toEqual(2);
@@ -463,7 +618,11 @@ describe("utils - EventEmitter", () => {
     expect(wasCalledWithString3).toEqual(1);
     expect(wasCalledWithObject3).toEqual(0);
 
-    (eventEmitter as any).trigger("nope", undefined);
+    (
+      eventEmitter as EventEmitter<unknown> & {
+        trigger(evtName: string, payload: unknown): void;
+      }
+    ).trigger("nope", undefined);
     expect(wasCalledWithString1).toEqual(2);
     expect(wasCalledWithObject1).toEqual(0);
     expect(wasCalledWithString2).toEqual(2);
@@ -471,7 +630,11 @@ describe("utils - EventEmitter", () => {
     expect(wasCalledWithString3).toEqual(1);
     expect(wasCalledWithObject3).toEqual(0);
 
-    (eventEmitter as any).trigger("nope", "a");
+    (
+      eventEmitter as EventEmitter<unknown> & {
+        trigger(evtName: string, payload: unknown): void;
+      }
+    ).trigger("nope", "a");
     expect(wasCalledWithString1).toEqual(3);
     expect(wasCalledWithObject1).toEqual(0);
     expect(wasCalledWithString2).toEqual(2);
@@ -479,7 +642,11 @@ describe("utils - EventEmitter", () => {
     expect(wasCalledWithString3).toEqual(2);
     expect(wasCalledWithObject3).toEqual(0);
 
-    (eventEmitter as any).trigger("something", { a: "b" });
+    (
+      eventEmitter as EventEmitter<unknown> & {
+        trigger(evtName: string, payload: unknown): void;
+      }
+    ).trigger("something", { a: "b" });
     expect(wasCalledWithString1).toEqual(3);
     expect(wasCalledWithObject1).toEqual(1);
     expect(wasCalledWithString2).toEqual(2);
@@ -495,7 +662,11 @@ describe("utils - EventEmitter", () => {
     expect(wasCalledWithString3).toEqual(2);
     expect(wasCalledWithObject3).toEqual(1);
 
-    (eventEmitter as any).trigger("something", { a: "b" });
+    (
+      eventEmitter as EventEmitter<unknown> & {
+        trigger(evtName: string, payload: unknown): void;
+      }
+    ).trigger("something", { a: "b" });
     expect(wasCalledWithString1).toEqual(3);
     expect(wasCalledWithObject1).toEqual(1);
     expect(wasCalledWithString2).toEqual(2);
@@ -503,7 +674,11 @@ describe("utils - EventEmitter", () => {
     expect(wasCalledWithString3).toEqual(2);
     expect(wasCalledWithObject3).toEqual(1);
 
-    (eventEmitter as any).trigger("nope", { a: "b" });
+    (
+      eventEmitter as EventEmitter<unknown> & {
+        trigger(evtName: string, payload: unknown): void;
+      }
+    ).trigger("nope", { a: "b" });
     expect(wasCalledWithString1).toEqual(3);
     expect(wasCalledWithObject1).toEqual(1);
     expect(wasCalledWithString2).toEqual(2);

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

@@ -1,9 +1,6 @@
 import { describe, beforeEach, afterEach, it, expect, vi } from "vitest";
 import flatMap from "../flat_map";
 
-/* eslint-disable @typescript-eslint/no-unsafe-member-access */
-/* eslint-disable @typescript-eslint/no-unsafe-assignment */
-
 interface IProtoWithFlatMap {
   flatMap?:
     | (<U, This = undefined>(
@@ -20,9 +17,8 @@ interface IProtoWithFlatMap {
 
 const proto = Array.prototype as unknown as IProtoWithFlatMap;
 
-/* eslint-disable @typescript-eslint/unbound-method */
+// eslint-disable-next-line @typescript-eslint/unbound-method
 const initialFlatMap = proto.flatMap;
-/* eslint-enable @typescript-eslint/unbound-method */
 
 describe("utils - starts-with", () => {
   beforeEach(() => {
@@ -44,7 +40,7 @@ describe("utils - starts-with", () => {
     it("should call the original flatMap function if available", () => {
       proto.flatMap = initialFlatMap;
       // TODO find what bother typescript here instead of adding "as any"
-      /* eslint-disable-next-line @typescript-eslint/no-explicit-any */
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
       const mockFlatMap = vi.spyOn(proto as any, "flatMap");
       const func1 = (x: number): number[] => [x, x + 1, x - 1];
       const func2 = (x: number): string => String(x) + "a";

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

@@ -1,21 +1,19 @@
 import { describe, beforeEach, afterEach, it, expect, vi } from "vitest";
 import startsWith from "../starts_with";
 
-/* eslint-disable no-restricted-properties */
-
-/* eslint-disable @typescript-eslint/unbound-method */
+// eslint-disable-next-line no-restricted-properties, @typescript-eslint/unbound-method
 const initialStartsWith = String.prototype.startsWith;
-/* eslint-enable @typescript-eslint/unbound-method */
 
 describe("utils - starts-with", () => {
   beforeEach(() => {
-    /* eslint-disable @typescript-eslint/no-explicit-any */
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
-    (String.prototype as any).startsWith = undefined;
-    /* eslint-enable @typescript-eslint/no-explicit-any */
+    // @ts-expect-error: We're setting `startsWith` to `undefined` to
+    // specifically test our own implementation
+    // eslint-disable-next-line no-restricted-properties
+    String.prototype.startsWith = undefined;
   });
 
   afterEach(() => {
+    // eslint-disable-next-line no-restricted-properties
     String.prototype.startsWith = initialStartsWith;
   });
 
@@ -34,6 +32,7 @@ describe("utils - starts-with", () => {
 
   if (typeof initialStartsWith === "function") {
     it("should call the original startsWith function if available", () => {
+      // eslint-disable-next-line no-restricted-properties
       String.prototype.startsWith = initialStartsWith;
       const mockStartsWith = vi.spyOn(String.prototype, "startsWith");
       const str = "Street Halo";

package/src/utils/array_find.ts

@@ -14,12 +14,6 @@
  * limitations under the License.
  */
 
-/* eslint-disable @typescript-eslint/no-unsafe-member-access */
-/* eslint-disable @typescript-eslint/explicit-module-boundary-types */
-/* eslint-disable @typescript-eslint/no-unsafe-call */
-/* eslint-disable @typescript-eslint/no-unsafe-return */
-/* eslint-disable no-restricted-properties */
-
 // Ugly transitory type to make duck typing work
 type ArrayWithFind<T> = T[] & {
   find(predicate: (value: T, index: number, obj: T[]) => unknown, thisArg?: unknown): T;
@@ -29,7 +23,7 @@ type ArrayWithFind<T> = T[] & {
  * Array.prototype.find ponyfill.
  * @param {Array} arr
  * @param {Function} predicate
- * @param {*} context
+ * @param {*} thisArg
  * @returns {boolean}
  */
 export default function arrayFind<T>(
@@ -37,7 +31,9 @@ export default function arrayFind<T>(
   predicate: (arg: T, index: number, fullArray: T[]) => boolean,
   thisArg?: unknown,
 ): T | undefined {
+  // eslint-disable-next-line no-restricted-properties, @typescript-eslint/unbound-method
   if (typeof (Array.prototype as ArrayWithFind<T>).find === "function") {
+    // eslint-disable-next-line no-restricted-properties
     return (arr as ArrayWithFind<T>).find(predicate, thisArg);
   }
 

package/src/utils/array_find_index.ts

@@ -14,12 +14,6 @@
  * limitations under the License.
  */
 
-/* eslint-disable @typescript-eslint/no-unsafe-member-access */
-/* eslint-disable @typescript-eslint/explicit-module-boundary-types */
-/* eslint-disable @typescript-eslint/no-unsafe-call */
-/* eslint-disable @typescript-eslint/no-unsafe-return */
-/* eslint-disable no-restricted-properties */
-
 // Ugly transitory type to make duck typing work
 type ArrayWithFindIndex<T> = T[] & {
   findIndex(
@@ -32,7 +26,7 @@ type ArrayWithFindIndex<T> = T[] & {
  * Array.prototype.find ponyfill.
  * @param {Array} arr
  * @param {Function} predicate
- * @param {*} context
+ * @param {*} thisArg
  * @returns {boolean}
  */
 export default function arrayFindIndex<T>(
@@ -40,7 +34,9 @@ export default function arrayFindIndex<T>(
   predicate: (arg: T, index: number, fullArray: T[]) => boolean,
   thisArg?: unknown,
 ): number {
+  // eslint-disable-next-line no-restricted-properties, @typescript-eslint/unbound-method
   if (typeof (Array.prototype as ArrayWithFindIndex<T>).findIndex === "function") {
+    // eslint-disable-next-line no-restricted-properties
     return (arr as ArrayWithFindIndex<T>).findIndex(predicate, thisArg);
   }
 

package/src/utils/array_includes.ts

@@ -56,10 +56,8 @@ export default function arrayIncludes<T>(
   searchElement: T,
   fromIndex?: number,
 ): boolean {
-  /* eslint-disable @typescript-eslint/unbound-method */
-  // eslint-disable-next-line no-restricted-properties
+  // eslint-disable-next-line no-restricted-properties, @typescript-eslint/unbound-method
   if (typeof Array.prototype.includes === "function") {
-    /* eslint-enable @typescript-eslint/unbound-method */
     // eslint-disable-next-line no-restricted-properties
     return arr.includes(searchElement, fromIndex);
   }

package/src/utils/assert.ts

@@ -73,12 +73,10 @@ export function assertInterface<T>(
   assert(!isNullOrUndefined(o), `${name} should be an object`);
   for (const k in iface) {
     if (iface.hasOwnProperty(k)) {
-      /* eslint-disable @typescript-eslint/restrict-template-expressions */
       assert(
         typeof o[k] === iface[k],
         `${name} should have property ${k} as a ${iface[k]}`,
       );
-      /* eslint-enable @typescript-eslint/restrict-template-expressions */
     }
   }
 }