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/agnostic/src/features/actual/listening-of-channels/listening-of-channels.injectable.ts

@@ -1,31 +1,31 @@
 import { getInjectable, getInjectionToken } from "@ogre-tools/injectable";
 import { enlistMessageChannelListenerInjectionToken } from "../message/enlist-message-channel-listener-injection-token";
-
 import { getStartableStoppable, StartableStoppable } from "@k8slens/startable-stoppable";
-
 import { computedInjectManyInjectable } from "@ogre-tools/injectable-extension-for-mobx";
 import { IComputedValue, reaction } from "mobx";
 
 import {
   MessageChannel,
+  MessageChannelListener,
   messageChannelListenerInjectionToken,
 } from "../message/message-channel-listener-injection-token";
 import {
   RequestChannel,
+  RequestChannelListener,
   requestChannelListenerInjectionToken,
 } from "../request/request-channel-listener-injection-token";
 import { enlistRequestChannelListenerInjectionToken } from "../request/enlist-request-channel-listener-injection-token";
+import type { Disposer } from "@k8slens/utilities";
 
 export type ListeningOfChannels = StartableStoppable;
 export const listeningOfChannelsInjectionToken = getInjectionToken<ListeningOfChannels>({
   id: "listening-of-channels-injection-token",
 });
 
-const listening = <T extends { id: string; channel: MessageChannel<any> | RequestChannel<any, any> }>(
-  channelListeners: IComputedValue<T[]>,
-  enlistChannelListener: (listener: T) => () => void,
-  getId: (listener: T) => string,
-) => {
+function messageListening<Message>(
+  channelListeners: IComputedValue<MessageChannelListener<MessageChannel<Message>>[]>,
+  enlistChannelListener: (listener: MessageChannelListener<MessageChannel<Message>>) => Disposer,
+): Disposer {
   const listenerDisposers = new Map<string, () => void>();
 
   const reactionDisposer = reaction(
@@ -38,23 +38,20 @@ const listening = <T extends { id: string; channel: MessageChannel<any> | Reques
       );
 
       addedListeners.forEach((listener) => {
-        const id = getId(listener);
-
-        if (listenerDisposers.has(id)) {
-          throw new Error(`Tried to add listener for channel "${listener.channel.id}" but listener already exists.`);
+        if (listenerDisposers.has(listener.id)) {
+          throw new Error(
+            `Tried to add listener "${listener.id}" for channel "${listener.channel.id}" but listener with a same ID already exists.`,
+          );
         }
 
         const disposer = enlistChannelListener(listener);
 
-        listenerDisposers.set(id, disposer);
+        listenerDisposers.set(listener.id, disposer);
       });
 
       removedListeners.forEach((listener) => {
-        const dispose = listenerDisposers.get(getId(listener));
-
-        dispose?.();
-
-        listenerDisposers.delete(getId(listener));
+        listenerDisposers.get(listener.id)?.();
+        listenerDisposers.delete(listener.id);
       });
     },
 
@@ -65,34 +62,69 @@ const listening = <T extends { id: string; channel: MessageChannel<any> | Reques
     reactionDisposer();
     listenerDisposers.forEach((dispose) => dispose());
   };
-};
+}
+
+function requestListening<Request, Response>(
+  channelListeners: IComputedValue<RequestChannelListener<RequestChannel<Request, Response>>[]>,
+  enlistChannelListener: (listener: RequestChannelListener<RequestChannel<Request, Response>>) => Disposer,
+): Disposer {
+  const listenerDisposers = new Map<string, () => void>();
+
+  const reactionDisposer = reaction(
+    () => channelListeners.get(),
+    (newValues, oldValues = []) => {
+      const addedListeners = newValues.filter(
+        (newValue) => !oldValues.some((oldValue) => oldValue.channel.id === newValue.channel.id),
+      );
+
+      const removedListeners = oldValues.filter(
+        (oldValue) => !newValues.some((newValue) => newValue.channel.id === oldValue.channel.id),
+      );
+
+      addedListeners.forEach((listener) => {
+        if (listenerDisposers.has(listener.channel.id)) {
+          throw new Error(
+            `Tried to add request listener for channel "${listener.channel.id}" but listener already exists.`,
+          );
+        }
+
+        const disposer = enlistChannelListener(listener);
+
+        listenerDisposers.set(listener.channel.id, disposer);
+      });
+
+      removedListeners.forEach((listener) => {
+        const dispose = listenerDisposers.get(listener.channel.id);
+
+        dispose?.();
+
+        listenerDisposers.delete(listener.channel.id);
+      });
+    },
+
+    { fireImmediately: true },
+  );
+
+  return () => {
+    reactionDisposer();
+    listenerDisposers.forEach((dispose) => dispose());
+  };
+}
 
 const listeningOfChannelsInjectable = getInjectable({
   id: "listening-of-channels",
 
   instantiate: (di) => {
     const enlistMessageChannelListener = di.inject(enlistMessageChannelListenerInjectionToken);
-
     const enlistRequestChannelListener = di.inject(enlistRequestChannelListenerInjectionToken);
-
     const computedInjectMany = di.inject(computedInjectManyInjectable);
 
     const messageChannelListeners = computedInjectMany(messageChannelListenerInjectionToken);
-
     const requestChannelListeners = computedInjectMany(requestChannelListenerInjectionToken);
 
     return getStartableStoppable("listening-of-channels", () => {
-      const stopListeningOfMessageChannels = listening(
-        messageChannelListeners,
-        enlistMessageChannelListener,
-        (x) => x.id,
-      );
-
-      const stopListeningOfRequestChannels = listening(
-        requestChannelListeners,
-        enlistRequestChannelListener,
-        (x) => x.channel.id,
-      );
+      const stopListeningOfMessageChannels = messageListening(messageChannelListeners, enlistMessageChannelListener);
+      const stopListeningOfRequestChannels = requestListening(requestChannelListeners, enlistRequestChannelListener);
 
       return () => {
         stopListeningOfMessageChannels();

packages/technical-features/messaging/agnostic/src/features/actual/listening-of-channels/start-listening-of-channels.injectable.ts

@@ -9,8 +9,8 @@ const startListeningOfChannelsInjectable = getInjectable({
     const listeningOfChannels = di.inject(listeningOfChannelsInjectionToken);
 
     return {
-      run: async () => {
-        await listeningOfChannels.start();
+      run: () => {
+        listeningOfChannels.start();
       },
     };
   },

packages/technical-features/messaging/agnostic/src/features/actual/request/request-channel-listener-injection-token.ts

@@ -12,7 +12,6 @@ export type RequestChannelHandler<Channel> = Channel extends RequestChannel<infe
   : never;
 
 export interface RequestChannelListener<Channel> {
-  id: string;
   channel: Channel;
   handler: RequestChannelHandler<Channel>;
 }