fix: Use Map for State (#27105)

Author: Nerivec

lib/eventBus.ts

@@ -35,7 +35,7 @@ type EventBusListener<K> = K extends keyof EventBusMap
     : never;
 
 export default class EventBus {
-    private callbacksByExtension: Map<string, {event: keyof EventBusMap; callback: EventBusListener<keyof EventBusMap>}[]> = new Map();
+    private callbacksByExtension = new Map<string, {event: keyof EventBusMap; callback: EventBusListener<keyof EventBusMap>}[]>();
     private emitter = new events.EventEmitter<EventBusMap>();
 
     constructor() {

lib/extension/availability.ts

@@ -20,15 +20,15 @@ const RETRIEVE_ON_RECONNECT: readonly {keys: string[]; condition?: (state: KeyVa
 
 export default class Availability extends Extension {
     /** Mapped by IEEE address */
-    private readonly timers: Map<string, NodeJS.Timeout> = new Map();
+    private readonly timers = new Map<string, NodeJS.Timeout>();
     /** Mapped by IEEE address or Group ID */
-    private readonly lastPublishedAvailabilities: Map<string | number, boolean> = new Map();
+    private readonly lastPublishedAvailabilities = new Map<string | number, boolean>();
     /** Mapped by IEEE address */
-    private readonly pingBackoffs: Map<string, number> = new Map();
+    private readonly pingBackoffs = new Map<string, number>();
     /** IEEE addresses, waiting for last seen changes to take them out of "availability sleep" */
-    private readonly backoffPausedDevices: Set<string> = new Set();
+    private readonly backoffPausedDevices = new Set<string>();
     /** Mapped by IEEE address */
-    private readonly retrieveStateDebouncers: Map<string, () => void> = new Map();
+    private readonly retrieveStateDebouncers = new Map<string, () => void>();
     private pingQueue: Device[] = [];
     private pingQueueExecuting = false;
     private stopped = false;

lib/extension/bind.ts

@@ -567,7 +567,7 @@ export default class Bind extends Extension {
         );
 
         if (polls.length) {
-            const toPoll: Set<zh.Endpoint> = new Set();
+            const toPoll = new Set<zh.Endpoint>();
 
             // Add bound devices
             for (const endpoint of data.device.zh.endpoints) {

lib/extension/groups.ts

@@ -106,7 +106,7 @@ export default class Groups extends Extension {
                 // Invalidate the last optimistic group state when group state is changed directly.
                 delete this.lastOptimisticState[entity.ID];
 
-                const groupsToPublish: Set<Group> = new Set();
+                const groupsToPublish = new Set<Group>();
 
                 for (const member of entity.zh.members) {
                     const device = this.zigbee.resolveEntity(member.getDevice()) as Device;

lib/extension/homeassistant.ts

@@ -1472,7 +1472,7 @@ export class HomeAssistant extends Extension {
         const discovered = this.getDiscovered(entity);
         discovered.discovered = true;
         const lastDiscoveredTopics = Object.keys(discovered.messages);
-        const newDiscoveredTopics: Set<string> = new Set();
+        const newDiscoveredTopics = new Set<string>();
 
         for (const config of this.getConfigs(entity)) {
             const payload = {...config.discovery_payload};

lib/extension/networkMap.ts

@@ -185,9 +185,9 @@ export default class NetworkMap extends Extension {
 
     async networkScan(includeRoutes: boolean): Promise<Zigbee2MQTTNetworkMap> {
         logger.info(`Starting network scan (includeRoutes '${includeRoutes}')`);
-        const lqis: Map<Device, zh.LQI> = new Map();
-        const routingTables: Map<Device, zh.RoutingTable> = new Map();
-        const failed: Map<Device, string[]> = new Map();
+        const lqis = new Map<Device, zh.LQI>();
+        const routingTables = new Map<Device, zh.RoutingTable>();
+        const failed = new Map<Device, string[]>();
         const requestWithRetry = async <T>(request: () => Promise<T>): Promise<T> => {
             try {
                 const result = await request();

lib/mqtt.ts

@@ -14,7 +14,7 @@ import utils from './util/utils';
 const NS = 'z2m:mqtt';
 
 export default class MQTT {
-    private publishedTopics: Set<string> = new Set();
+    private publishedTopics = new Set<string>();
     private connectionTimer?: NodeJS.Timeout;
     private client!: MqttClient;
     private eventBus: EventBus;

lib/state.ts

@@ -1,4 +1,4 @@
-import fs from 'node:fs';
+import {existsSync, readFileSync, writeFileSync} from 'node:fs';
 
 import objectAssignDeep from 'object-assign-deep';
 
@@ -7,9 +7,8 @@ import logger from './util/logger';
 import * as settings from './util/settings';
 import utils from './util/utils';
 
-const saveInterval = 1000 * 60 * 5; // 5 minutes
-
-const dontCacheProperties = [
+const SAVE_INTERVAL = 1000 * 60 * 5; // 5 minutes
+const CACHE_IGNORE_PROPERTIES = [
     'action',
     'action_.*',
     'button',
@@ -32,8 +31,8 @@ const dontCacheProperties = [
 ];
 
 class State {
-    private state: {[s: string | number]: KeyValue} = {};
-    private file = data.joinPath('state.json');
+    private readonly state = new Map<string | number, KeyValue>();
+    private readonly file = data.joinPath('state.json');
     private timer?: NodeJS.Timeout;
 
     constructor(
@@ -48,26 +47,37 @@ class State {
         this.load();
 
         // Save the state on every interval
-        this.timer = setInterval(() => this.save(), saveInterval);
+        this.timer = setInterval(() => this.save(), SAVE_INTERVAL);
     }
 
     stop(): void {
         // Remove any invalid states (ie when the device has left the network) when the system is stopped
-        for (const key in this.state) {
-            if (typeof key === 'string' && !this.zigbee.resolveEntity(key)) {
+        for (const [key] of this.state) {
+            if (typeof key === 'string' && key.startsWith('0x') && !this.zigbee.resolveEntity(key)) {
                 // string key = ieeeAddr
-                delete this.state[key];
+                this.state.delete(key);
             }
         }
 
         clearTimeout(this.timer);
         this.save();
     }
 
+    clear(): void {
+        this.state.clear();
+    }
+
     private load(): void {
-        if (fs.existsSync(this.file)) {
+        this.state.clear();
+
+        if (existsSync(this.file)) {
             try {
-                this.state = JSON.parse(fs.readFileSync(this.file, 'utf8'));
+                const stateObj = JSON.parse(readFileSync(this.file, 'utf8')) as KeyValue;
+
+                for (const key in stateObj) {
+                    this.state.set(key.startsWith('0x') ? key : Number.parseInt(key, 10), stateObj[key]);
+                }
+
                 logger.debug(`Loaded state from file ${this.file}`);
             } catch (error) {
                 logger.debug(`Failed to load state from file ${this.file} (corrupt file?) (${(error as Error).message})`);
@@ -80,9 +90,11 @@ class State {
     private save(): void {
         if (settings.get().advanced.cache_state_persistent) {
             logger.debug(`Saving state to file ${this.file}`);
-            const json = JSON.stringify(this.state, null, 4);
+
+            const json = JSON.stringify(Object.fromEntries(this.state), null, 4);
+
             try {
-                fs.writeFileSync(this.file, json, 'utf8');
+                writeFileSync(this.file, json, 'utf8');
             } catch (error) {
                 logger.error(`Failed to write state to '${this.file}' (${error})`);
             }
@@ -92,28 +104,28 @@ class State {
     }
 
     exists(entity: Device | Group): boolean {
-        return this.state[entity.ID] !== undefined;
+        return this.state.has(entity.ID);
     }
 
     get(entity: Group | Device): KeyValue {
-        return this.state[entity.ID] || {};
+        return this.state.get(entity.ID) || {};
     }
 
     set(entity: Group | Device, update: KeyValue, reason?: string): KeyValue {
-        const fromState = this.state[entity.ID] || {};
+        const fromState = this.state.get(entity.ID) || {};
         const toState = objectAssignDeep({}, fromState, update);
         const newCache = {...toState};
         const entityDontCacheProperties = entity.options.filtered_cache || [];
 
-        utils.filterProperties(dontCacheProperties.concat(entityDontCacheProperties), newCache);
+        utils.filterProperties(CACHE_IGNORE_PROPERTIES.concat(entityDontCacheProperties), newCache);
 
-        this.state[entity.ID] = newCache;
+        this.state.set(entity.ID, newCache);
         this.eventBus.emitStateChange({entity, from: fromState, to: toState, reason, update});
         return toState;
     }
 
-    remove(ID: string | number): void {
-        delete this.state[ID];
+    remove(ID: string | number): boolean {
+        return this.state.delete(ID);
     }
 }
 

lib/util/settingsMigration.ts

@@ -510,7 +510,7 @@ export function migrateIfNecessary(): void {
     while (currentSettings.version !== finalVersion) {
         let migrationNotesFileName: string | undefined;
         // don't duplicate outputs
-        const migrationNotes: Set<string> = new Set();
+        const migrationNotes = new Set<string>();
         const transfers: SettingsTransfer[] = [];
         const changes: SettingsChange[] = [];
         const additions: SettingsAdd[] = [];

lib/zigbee.ts

@@ -21,8 +21,8 @@ export default class Zigbee {
     // @ts-expect-error initialized in start
     private herdsman: Controller;
     private eventBus: EventBus;
-    private groupLookup: Map<number /* group ID */, Group> = new Map();
-    private deviceLookup: Map<string /* IEEE address */, Device> = new Map();
+    private groupLookup = new Map<number /* group ID */, Group>();
+    private deviceLookup = new Map<string /* IEEE address */, Device>();
 
     constructor(eventBus: EventBus) {
         this.eventBus = eventBus;