refactor to integrate messageStore and unreadCounts

src/core/stores/appStore.ts

@@ -8,7 +8,6 @@ export interface RasterSource {
   tileSize: number;
 }
 
-
 interface ErrorState {
   field: string;
   message: string;
@@ -19,12 +18,7 @@ interface ErrorState {
   message: string;
 }
 
-export interface App {
-  unreadCounts: Map<number, number>;
-  setUnread: (id: number, count: number) => void;
-}
-
-export interface AppState {
+interface AppState {
   selectedDevice: number;
   devices: {
     id: number;
@@ -36,7 +30,6 @@ export interface AppState {
   connectDialogOpen: boolean;
   nodeNumDetails: number;
   errors: ErrorState[];
-  unreadCounts: Map<number, number>;
 
   setRasterSources: (sources: RasterSource[]) => void;
   addRasterSource: (source: RasterSource) => void;
@@ -57,9 +50,6 @@ export interface AppState {
   removeError: (field: string) => void;
   clearErrors: () => void;
   setNewErrors: (newErrors: ErrorState[]) => void;
-
-  // unread counts
-  setUnread: (id: number, count: number) => void;
 }
 
 export const useAppStore = create<AppState>()((set, get) => ({
@@ -72,7 +62,6 @@ export const useAppStore = create<AppState>()((set, get) => ({
   nodeNumToBeRemoved: 0,
   nodeNumDetails: 0,
   errors: [],
-  unreadCounts: new Map([[0, 100],[2718471552, 1]]),
 
   setRasterSources: (sources: RasterSource[]) => {
     set(
@@ -173,11 +162,4 @@ export const useAppStore = create<AppState>()((set, get) => ({
       }),
     );
   },
-  setUnread: (id: number, count: number) => {
-    set(
-      produce<AppState>((draft) => {
-        draft.unreadCounts.set(id, count);
-      })
-    );
-  }
 }));

src/core/stores/deviceStore.ts

@@ -74,7 +74,6 @@ export interface Device {
     refreshKeys: boolean;
     clearMessages: boolean;
   };
-  unreadCounts: Map<number, number>;
 
 
   setStatus: (status: Types.DeviceStatusEnum) => void;
@@ -102,11 +101,12 @@ export interface Device {
   getDialogOpen: (dialog: DialogVariant) => boolean;
   processPacket: (data: ProcessPacketParams) => void;
   setMessageDraft: (message: string) => void;
-  setUnread: (id: number, count: number) => void;
   setNodeError: (nodeNum: number, error: string) => void;
   clearNodeError: (nodeNum: number) => void;
   getNodeError: (nodeNum: number) => NodeError | undefined;
   hasNodeError: (nodeNum: number) => boolean
+  incrementUnread: (nodeNum: number) => void;
+  resetUnread: (nodeNum: number) => void;
 }
 
 export interface DeviceState {
@@ -154,12 +154,13 @@ export const useDeviceStore = createStore<DeviceState>((set, get) => ({
             unsafeRoles: false,
             refreshKeys: false,
             rebootOTA: false,
+            clearMessages: false,
           },
           pendingSettingsChanges: false,
           messageDraft: "",
-          unreadCounts: new Map(),
           nodeErrors: new Map(),
 
+
           setStatus: (status: Types.DeviceStatusEnum) => {
             set(
               produce<DeviceState>((draft) => {
@@ -581,20 +582,6 @@ export const useDeviceStore = createStore<DeviceState>((set, get) => ({
               }),
             );
           },
-          setUnread: (unread_id: number, count?: number) => {
-              set(
-                produce<DeviceState>((draft) => {
-                  const device = draft.devices.get(id);
-                  if (device) {
-                    if (count == null) {
-                      let currentCount = device.unreadCounts.get(unread_id) ?? 0;
-                      count = currentCount + 1;
-                    }
-                    device.unreadCounts.set(unread_id, count);
-                  }
-                })
-              );
-            },
           setNodeError: (nodeNum, error) => {
             set(
               produce<DeviceState>((draft) => {
@@ -629,7 +616,35 @@ export const useDeviceStore = createStore<DeviceState>((set, get) => ({
             }
             return device.nodeErrors.has(nodeNum);
           },
+          incrementUnread: (nodeNum: number) => {
+            set(
+              produce<DeviceState>((draft) => {
+                const device = draft.devices.get(id);
+                if (!device) {
+                  console.warn(`incrementUnread: Device with ID ${id} not found.`);
+                  return;
+                }
+                const currentCount = device.unreadCounts.get(nodeNum) ?? 0;
+                device.unreadCounts.set(nodeNum, currentCount + 1);
+              })
+            );
+          },
+          resetUnread: (nodeNum: number) => {
+            set(
+              produce<DeviceState>((draft) => {
+                const device = draft.devices.get(id);
+                if (!device) {
+                  console.warn(`resetUnread: Device with ID ${id} not found.`);
+                  return;
+                }
+                device.unreadCounts.set(nodeNum, 0);
 
+                if (device.unreadCounts.get(nodeNum) === 0) {
+                  device.unreadCounts.delete(nodeNum);
+                }
+              })
+            );
+          },
         });
       }),
     );

src/core/stores/messageStore.test.ts

@@ -9,19 +9,15 @@ import {
 let memoryStorage: Record<string, string> = {};
 
 vi.mock('./storage/indexDB.ts', () => {
-  console.log("Mocking zustandIndexDBStorage...");
   return {
     zustandIndexDBStorage: {
       getItem: vi.fn(async (name: string): Promise<string | null> => {
-        console.log(`Mock getItem: ${name}`, memoryStorage[name] ?? null);
         return memoryStorage[name] ?? null;
       }),
       setItem: vi.fn(async (name: string, value: string): Promise<void> => {
-        console.log(`Mock setItem: ${name}`, value);
         memoryStorage[name] = value;
       }),
       removeItem: vi.fn(async (name: string): Promise<void> => {
-        console.log(`Mock removeItem: ${name}`);
         delete memoryStorage[name];
       }),
     },
@@ -211,11 +207,14 @@ describe('useMessageStore', () => {
       expect(messages).toEqual([]);
     });
 
-    it('should return empty array if myNodeNum is not provided for direct messages', () => {
+    it('should return combined direct messages when myNodeNum and otherNodeNum are provided', () => {
       const messages = useMessageStore.getState().getMessages(MessageType.Direct, {
+        myNodeNum: myNodeNum,         // Keep this
         otherNodeNum: otherNodeNum1
       });
-      expect(messages).toEqual([]);
+      expect(messages).toHaveLength(2);
+      expect(messages[0]).toEqual(directMessageToOther1);
+      expect(messages[1]).toEqual(directMessageFromOther1);
     });
   });
 

src/core/subscriptions.ts

@@ -1,10 +1,8 @@
 import type { Device } from "@core/stores/deviceStore.ts";
 import { MeshDevice, Protobuf } from "@meshtastic/core";
-import type { MessageStore, MessageType } from "@core/stores/messageStore.ts";
-import { MessageType } from "@core/stores/messageStore.ts";
+import type { MessageStore } from "@core/stores/messageStore.ts";
 import PacketToMessageDTO from "@core/dto/PacketToMessageDTO.ts";
 
-
 export const subscribeAll = (
   device: Device,
   connection: MeshDevice,
@@ -87,15 +85,20 @@ export const subscribeAll = (
 
 
   connection.events.onMessagePacket.subscribe((messagePacket) => {
+    // incoming and outgoing messages are handled by this event listener
     const dto = new PacketToMessageDTO(messagePacket, myNodeNum);
     const message = dto.toMessage();
-    messsageStore.saveMessage(message);
-    
-    message.type == MessageType.Direct 
-      ? 
-      device.setUnread(messagePacket.from);
-      :
-      device.setUnread(messagePacket.channel);  
+    messageStore.saveMessage(message);
+
+    if (message.type == MessageType.Direct) {
+      if (message.to === myNodeNum) {
+        device.incrementUnread(messagePacket.from);
+      }
+    } else if (message.type == MessageType.Broadcast) {
+      if (message.from !== myNodeNum) {
+        device.incrementUnread(message.channel);
+      }
+    }
   });
 
   connection.events.onTraceRoutePacket.subscribe((traceRoutePacket) => {