chore: Fix lint for non @k8slens/core packages

- Update eslint config to be tighter in control

Signed-off-by: Sebastian Malton <sebastian@malton.name>

packages/technical-features/messaging/message-bridge-fake/src/get-message-bridge-fake/get-message-bridge-fake.test.ts

@@ -16,7 +16,7 @@ import {
 import { registerMobX } from "@ogre-tools/injectable-extension-for-mobx";
 import { runInAction } from "mobx";
 import { getPromiseStatus } from "@k8slens/test-utils";
-import { getMessageBridgeFake } from "./get-message-bridge-fake";
+import { getMessageBridgeFake, MessageBridgeFake } from "./get-message-bridge-fake";
 import { startApplicationInjectionToken } from "@k8slens/application";
 
 type SomeMessageChannel = MessageChannel<string>;
@@ -33,7 +33,7 @@ const someRequestChannelWithoutListeners: SomeRequestChannel = {
 
 [{ scenarioIsAsync: true }, { scenarioIsAsync: false }].forEach(({ scenarioIsAsync }) =>
   describe(`get-message-bridge-fake, given running as ${scenarioIsAsync ? "async" : "sync"}`, () => {
-    let messageBridgeFake: any;
+    let messageBridgeFake: MessageBridgeFake;
 
     beforeEach(() => {
       messageBridgeFake = getMessageBridgeFake();
@@ -142,15 +142,14 @@ const someRequestChannelWithoutListeners: SomeRequestChannel = {
               ? "when all message steps are propagated using a wrapper"
               : "immediately";
 
-            // eslint-disable-next-line jest/valid-title
             describe(scenarioTitle, () => {
-              let someWrapper: jest.Mock;
+              let someWrapper: jest.MockedFunction<() => Promise<void>>;
 
               beforeEach((done) => {
-                someWrapper = jest.fn((propagation) => propagation());
+                someWrapper = jest.fn().mockImplementation((propagation: () => Promise<void>) => propagation());
 
                 if (scenarioIsAsync) {
-                  messageBridgeFake.messagePropagationRecursive(someWrapper).then(done);
+                  void messageBridgeFake.messagePropagationRecursive(someWrapper).then(done);
                 } else {
                   done();
                 }
@@ -163,21 +162,21 @@ const someRequestChannelWithoutListeners: SomeRequestChannel = {
                 });
               });
 
-              scenarioIsAsync &&
+              if (scenarioIsAsync) {
                 it("the wrapper gets called with the both propagations", () => {
                   expect(someWrapper).toHaveBeenCalledTimes(2);
                 });
+              }
             });
 
             const scenarioName: string = scenarioIsAsync
               ? "when all message steps are propagated not using a wrapper"
               : "immediately";
 
-            // eslint-disable-next-line jest/valid-title
             describe(scenarioName, () => {
               beforeEach((done) => {
                 if (scenarioIsAsync) {
-                  messageBridgeFake.messagePropagationRecursive().then(done);
+                  void messageBridgeFake.messagePropagationRecursive().then(done);
                 } else {
                   done();
                 }
@@ -204,19 +203,19 @@ const someRequestChannelWithoutListeners: SomeRequestChannel = {
             expect(someHandler1MockInDi1).not.toHaveBeenCalled();
           });
 
-          scenarioIsAsync &&
+          if (scenarioIsAsync) {
             it("listeners in other than sending DIs do not handle the message yet", () => {
               expect(someHandler1MockInDi2).not.toHaveBeenCalled();
               expect(someHandler2MockInDi2).not.toHaveBeenCalled();
             });
+          }
 
           const scenarioName = scenarioIsAsync ? "when messages are propagated" : "immediately";
 
-          // eslint-disable-next-line jest/valid-title
           describe(scenarioName, () => {
             beforeEach((done) => {
               if (scenarioIsAsync) {
-                messageBridgeFake.messagePropagation().then(done);
+                void messageBridgeFake.messagePropagation().then(done);
               } else {
                 done();
               }
@@ -235,12 +234,12 @@ const someRequestChannelWithoutListeners: SomeRequestChannel = {
             });
           });
 
-          scenarioIsAsync &&
+          if (scenarioIsAsync) {
             describe("when messages are propagated using a wrapper, such as act() in react testing lib", () => {
-              let someWrapper: jest.Mock;
+              let someWrapper: jest.MockedFunction<() => Promise<void>>;
 
               beforeEach(async () => {
-                someWrapper = jest.fn((observation) => observation());
+                someWrapper = jest.fn().mockImplementation((propagation: () => Promise<void>) => propagation());
 
                 await messageBridgeFake.messagePropagation(someWrapper);
               });
@@ -261,6 +260,7 @@ const someRequestChannelWithoutListeners: SomeRequestChannel = {
                 });
               });
             });
+          }
         });
 
         it("given a listener is deregistered, when sending message, deregistered listener does not handle the message", () => {

packages/technical-features/messaging/message-bridge-fake/src/get-message-bridge-fake/get-message-bridge-fake.ts

@@ -5,6 +5,7 @@ import type {
   MessageChannelListener,
   RequestChannel,
   RequestChannelHandler,
+  RequestChannelListener,
 } from "@k8slens/messaging";
 
 import {
@@ -21,27 +22,26 @@ import asyncFn, { AsyncFnMock } from "@async-fn/jest";
 
 export type MessageBridgeFake = {
   involve: (...dis: DiContainer[]) => void;
-  messagePropagation: () => Promise<void>;
-  messagePropagationRecursive: (callback: () => any) => any;
+  messagePropagation: (callback?: () => Promise<void>) => Promise<void>;
+  messagePropagationRecursive: (callback?: () => Promise<void>) => Promise<void>;
   setAsync: (value: boolean) => void;
 };
 
-type MessageHandlers = Set<MessageChannelHandler<MessageChannel<any>>>;
+type MessageHandlers = Set<MessageChannelHandler<MessageChannel<unknown>>>;
+
+interface OverrideMessagingArgs {
+  di: DiContainer;
+  messageListenersByDi: Map<DiContainer, Map<string, MessageHandlers>>;
+  messagePropagationBuffer: Set<AsyncFnMock<() => Promise<void>>>;
+  getAsyncModeStatus: () => boolean;
+}
 
 const overrideMessaging = ({
   di,
   messageListenersByDi,
   messagePropagationBuffer,
   getAsyncModeStatus,
-}: {
-  di: DiContainer;
-
-  messageListenersByDi: Map<DiContainer, Map<string, MessageHandlers>>;
-
-  messagePropagationBuffer: Set<{ resolve: () => Promise<void> }>;
-
-  getAsyncModeStatus: () => boolean;
-}) => {
+}: OverrideMessagingArgs) => {
   const messageHandlersByChannel = new Map<string, MessageHandlers>();
 
   messageListenersByDi.set(di, messageHandlersByChannel);
@@ -59,9 +59,9 @@ const overrideMessaging = ({
       }
 
       if (getAsyncModeStatus()) {
-        const resolvableHandlePromise = asyncFn();
+        const resolvableHandlePromise = asyncFn<() => Promise<void>>();
 
-        resolvableHandlePromise().then(() => {
+        void resolvableHandlePromise().then(() => {
           handlersForChannel.forEach((handler) => handler(message, { frameId: 42, processId: 42 }));
         });
 
@@ -74,24 +74,23 @@ const overrideMessaging = ({
 
   di.override(
     enlistMessageChannelListenerInjectionToken,
-    () =>
-      <T>(listener: MessageChannelListener<MessageChannel<T>>) => {
-        if (!messageHandlersByChannel.has(listener.channel.id)) {
-          messageHandlersByChannel.set(listener.channel.id, new Set());
-        }
+    () => (listener: MessageChannelListener<MessageChannel<unknown>>) => {
+      if (!messageHandlersByChannel.has(listener.channel.id)) {
+        messageHandlersByChannel.set(listener.channel.id, new Set());
+      }
 
-        const handlerSet = messageHandlersByChannel.get(listener.channel.id);
+      const handlerSet = messageHandlersByChannel.get(listener.channel.id);
 
-        handlerSet?.add(listener.handler);
+      handlerSet?.add(listener.handler);
 
-        return () => {
-          handlerSet?.delete(listener.handler);
-        };
-      },
+      return () => {
+        handlerSet?.delete(listener.handler);
+      };
+    },
   );
 };
 
-type RequestHandlers = Set<RequestChannelHandler<RequestChannel<any, any>>>;
+type RequestHandlers = Set<RequestChannelHandler<RequestChannel<unknown, unknown>>>;
 
 const overrideRequesting = ({
   di,
@@ -128,9 +127,7 @@ const overrideRequesting = ({
             }
 
             const listeners = channelSpecificListeners[0];
-
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            const [handler] = listeners!;
+            const [handler] = listeners ?? [];
 
             return handler;
           },
@@ -139,35 +136,41 @@ const overrideRequesting = ({
         )) as RequestFromChannel,
   );
 
-  di.override(enlistRequestChannelListenerInjectionToken, () => (listener) => {
-    if (!requestHandlersByChannel.has(listener.channel.id)) {
-      requestHandlersByChannel.set(listener.channel.id, new Set());
-    }
+  di.override(
+    enlistRequestChannelListenerInjectionToken,
+    () => (listener: RequestChannelListener<RequestChannel<unknown, unknown>>) => {
+      if (!requestHandlersByChannel.has(listener.channel.id)) {
+        requestHandlersByChannel.set(listener.channel.id, new Set());
+      }
 
-    const handlerSet = requestHandlersByChannel.get(listener.channel.id);
+      const handlerSet = requestHandlersByChannel.get(listener.channel.id);
 
-    handlerSet?.add(listener.handler);
+      handlerSet?.add(listener.handler);
 
-    return () => {
-      handlerSet?.delete(listener.handler);
-    };
-  });
+      return () => {
+        handlerSet?.delete(listener.handler);
+      };
+    },
+  );
 };
 
 export const getMessageBridgeFake = (): MessageBridgeFake => {
   const messageListenersByDi = new Map<DiContainer, Map<string, MessageHandlers>>();
   const requestListenersByDi = new Map<DiContainer, Map<string, RequestHandlers>>();
+  const messagePropagationBuffer = new Set<AsyncFnMock<() => Promise<void>>>();
 
-  const messagePropagationBuffer = new Set<AsyncFnMock<() => void>>();
-
-  const messagePropagation = async (wrapper: (callback: any) => any = (callback) => callback()) => {
+  const messagePropagation = async (
+    wrapper: (callback: () => Promise<void>) => Promise<void> = (callback) => callback(),
+  ) => {
     const oldMessages = [...messagePropagationBuffer.values()];
 
     messagePropagationBuffer.clear();
     await Promise.all(oldMessages.map((x) => wrapper(x.resolve)));
   };
 
-  const messagePropagationRecursive = async (wrapper = (callback: () => any) => callback()) => {
+  const messagePropagationRecursive = async (
+    wrapper: (callback: () => Promise<void>) => Promise<void> = (callback) => callback(),
+  ) => {
     while (messagePropagationBuffer.size) {
       await messagePropagation(wrapper);
     }