Enforce TS strict type checking.

lib/controller.ts

@@ -119,13 +119,28 @@ export class Controller {
             new ExtensionReport(...this.extensionArgs),
             new ExtensionExternalExtension(...this.extensionArgs),
             new ExtensionAvailability(...this.extensionArgs),
-            settings.get().frontend && new ExtensionFrontend(...this.extensionArgs),
-            settings.get().advanced.legacy_api && new ExtensionBridgeLegacy(...this.extensionArgs),
-            settings.get().external_converters.length && new ExtensionExternalConverters(...this.extensionArgs),
-            settings.get().homeassistant && new ExtensionHomeAssistant(...this.extensionArgs),
-            /* istanbul ignore next */
-            settings.get().advanced.soft_reset_timeout !== 0 && new ExtensionSoftReset(...this.extensionArgs),
-        ].filter((n) => n);
+        ];
+
+        if (settings.get().frontend) {
+            this.extensions.push(new ExtensionFrontend(...this.extensionArgs));
+        }
+
+        if (settings.get().advanced.legacy_api) {
+            this.extensions.push(new ExtensionBridgeLegacy(...this.extensionArgs));
+        }
+
+        if (settings.get().external_converters.length) {
+            this.extensions.push(new ExtensionExternalConverters(...this.extensionArgs));
+        }
+
+        if (settings.get().homeassistant) {
+            this.extensions.push(new ExtensionHomeAssistant(...this.extensionArgs));
+        }
+
+        /* istanbul ignore next */
+        if (settings.get().advanced.soft_reset_timeout !== 0) {
+            this.extensions.push(new ExtensionSoftReset(...this.extensionArgs));
+        }
     }
 
     async start(): Promise<void> {
@@ -143,7 +158,7 @@ export class Controller {
             logger.error('Failed to start zigbee');
             logger.error('Check https://www.zigbee2mqtt.io/guide/installation/20_zigbee2mqtt-fails-to-start.html for possible solutions');
             logger.error('Exiting...');
-            logger.error(error.stack);
+            logger.error((error as Error).stack!);
             return this.exit(1);
         }
 
@@ -160,8 +175,9 @@ export class Controller {
         let deviceCount = 0;
 
         for (const device of this.zigbee.devicesIterator(utils.deviceNotCoordinator)) {
+            // `definition` validated by `isSupported`
             const model = device.isSupported
-                ? `${device.definition.model} - ${device.definition.vendor} ${device.definition.description}`
+                ? `${device.definition!.model} - ${device.definition!.vendor} ${device.definition!.description}`
                 : 'Not supported';
             logger.info(`${device.name} (${device.ieeeAddr}): ${model} (${device.zh.type})`);
 
@@ -180,14 +196,14 @@ export class Controller {
 
             await this.zigbee.permitJoin(settings.get().permit_join);
         } catch (error) {
-            logger.error(`Failed to set permit join to ${settings.get().permit_join} (${error.message})`);
+            logger.error(`Failed to set permit join to ${settings.get().permit_join} (${(error as Error).message})`);
         }
 
         // MQTT
         try {
             await this.mqtt.connect();
         } catch (error) {
-            logger.error(`MQTT failed to connect, exiting... (${error.message})`);
+            logger.error(`MQTT failed to connect, exiting... (${(error as Error).message})`);
             await this.zigbee.stop();
             return this.exit(1);
         }
@@ -252,7 +268,7 @@ export class Controller {
             await this.zigbee.stop();
             logger.info('Stopped Zigbee2MQTT');
         } catch (error) {
-            logger.error(`Failed to stop Zigbee2MQTT (${error.message})`);
+            logger.error(`Failed to stop Zigbee2MQTT (${(error as Error).message})`);
             code = 1;
         }
 
@@ -377,7 +393,7 @@ export class Controller {
                 await extension[method]?.();
             } catch (error) {
                 /* istanbul ignore next */
-                logger.error(`Failed to call '${extension.constructor.name}' '${method}' (${error.stack})`);
+                logger.error(`Failed to call '${extension.constructor.name}' '${method}' (${(error as Error).stack})`);
             }
         }
     }

lib/eventBus.ts

@@ -5,9 +5,39 @@ import logger from './util/logger';
 // eslint-disable-next-line
 type ListenerKey = object;
 
+interface EventBusMap {
+    adapterDisconnected: [];
+    permitJoinChanged: [data: eventdata.PermitJoinChanged];
+    publishAvailability: [];
+    deviceRenamed: [data: eventdata.EntityRenamed];
+    deviceRemoved: [data: eventdata.EntityRemoved];
+    lastSeenChanged: [data: eventdata.LastSeenChanged];
+    deviceNetworkAddressChanged: [data: eventdata.DeviceNetworkAddressChanged];
+    deviceAnnounce: [data: eventdata.DeviceAnnounce];
+    deviceInterview: [data: eventdata.DeviceInterview];
+    deviceJoined: [data: eventdata.DeviceJoined];
+    entityOptionsChanged: [data: eventdata.EntityOptionsChanged];
+    exposesChanged: [data: eventdata.ExposesChanged];
+    deviceLeave: [data: eventdata.DeviceLeave];
+    deviceMessage: [data: eventdata.DeviceMessage];
+    mqttMessage: [data: eventdata.MQTTMessage];
+    mqttMessagePublished: [data: eventdata.MQTTMessagePublished];
+    publishEntityState: [data: eventdata.PublishEntityState];
+    groupMembersChanged: [data: eventdata.GroupMembersChanged];
+    devicesChanged: [];
+    scenesChanged: [data: eventdata.ScenesChanged];
+    reconfigure: [data: eventdata.Reconfigure];
+    stateChange: [data: eventdata.StateChange];
+}
+type EventBusListener<K> = K extends keyof EventBusMap
+    ? EventBusMap[K] extends unknown[]
+        ? (...args: EventBusMap[K]) => Promise<void> | void
+        : never
+    : never;
+
 export default class EventBus {
-    private callbacksByExtension: {[s: string]: {event: string; callback: (...args: unknown[]) => void}[]} = {};
-    private emitter = new events.EventEmitter();
+    private callbacksByExtension: {[s: string]: {event: keyof EventBusMap; callback: EventBusListener<keyof EventBusMap>}[]} = {};
+    private emitter = new events.EventEmitter<EventBusMap>();
 
     constructor() {
         this.emitter.setMaxListeners(100);
@@ -167,18 +197,22 @@ export default class EventBus {
         this.on('stateChange', callback, key);
     }
 
-    private on(event: string, callback: (...args: unknown[]) => Promise<void> | void, key: ListenerKey): void {
-        if (!this.callbacksByExtension[key.constructor.name]) this.callbacksByExtension[key.constructor.name] = [];
-        const wrappedCallback = async (...args: unknown[]): Promise<void> => {
+    private on<K extends keyof EventBusMap>(event: K, callback: EventBusListener<K>, key: ListenerKey): void {
+        if (!this.callbacksByExtension[key.constructor.name]) {
+            this.callbacksByExtension[key.constructor.name] = [];
+        }
+
+        const wrappedCallback = async (...args: never[]): Promise<void> => {
             try {
                 await callback(...args);
             } catch (error) {
-                logger.error(`EventBus error '${key.constructor.name}/${event}': ${error.message}`);
-                logger.debug(error.stack);
+                logger.error(`EventBus error '${key.constructor.name}/${event}': ${(error as Error).message}`);
+                logger.debug((error as Error).stack!);
             }
         };
+
         this.callbacksByExtension[key.constructor.name].push({event, callback: wrappedCallback});
-        this.emitter.on(event, wrappedCallback);
+        this.emitter.on(event, wrappedCallback as EventBusListener<K>);
     }
 
     public removeListeners(key: ListenerKey): void {

lib/extension/availability.ts

@@ -1,3 +1,4 @@
+import assert from 'assert';
 import bind from 'bind-decorator';
 import debounce from 'debounce';
 import * as zhc from 'zigbee-herdsman-converters';
@@ -41,9 +42,12 @@ export default class Availability extends Extension {
     }
 
     private isAvailable(entity: Device | Group): boolean {
-        return entity.isDevice()
-            ? Date.now() - entity.zh.lastSeen < this.getTimeout(entity)
-            : entity.membersDevices().length === 0 || entity.membersDevices().some((d) => this.availabilityCache[d.ieeeAddr]);
+        if (entity.isDevice()) {
+            return Date.now() - entity.zh.lastSeen < this.getTimeout(entity);
+        } else {
+            const membersDevices = entity.membersDevices();
+            return membersDevices.length === 0 || membersDevices.some((d) => this.availabilityCache[d.ieeeAddr]);
+        }
     }
 
     private resetTimer(device: Device): void {
@@ -92,7 +96,7 @@ export default class Availability extends Extension {
                 logger.debug(`Successfully pinged '${device.name}' (attempt ${i}/${attempts})`);
                 break;
             } catch (error) {
-                logger.warning(`Failed to ping '${device.name}' (attempt ${i}/${attempts}, ${error.message})`);
+                logger.warning(`Failed to ping '${device.name}' (attempt ${i}/${attempts}, ${(error as Error).message})`);
 
                 // Try again in 3 seconds.
                 if (i !== attempts) {
@@ -125,7 +129,7 @@ export default class Availability extends Extension {
 
         this.eventBus.onEntityRenamed(this, async (data) => {
             if (utils.isAvailabilityEnabledForEntity(data.entity, settings.get())) {
-                await this.mqtt.publish(`${data.from}/availability`, null, {retain: true, qos: 1});
+                await this.mqtt.publish(`${data.from}/availability`, '', {retain: true, qos: 1});
                 await this.publishAvailability(data.entity, false, true);
             }
         });
@@ -163,6 +167,7 @@ export default class Availability extends Extension {
     private async publishAvailability(entity: Device | Group, logLastSeen: boolean, forcePublish = false, skipGroups = false): Promise<void> {
         if (logLastSeen && entity.isDevice()) {
             const ago = Date.now() - entity.zh.lastSeen;
+
             if (this.isActiveDevice(entity)) {
                 logger.debug(`Active device '${entity.name}' was last seen '${(ago / utils.minutes(1)).toFixed(2)}' minutes ago.`);
             } else {
@@ -230,22 +235,24 @@ export default class Availability extends Extension {
                         continue;
                     }
 
-                    const converter = device.definition.toZigbee.find((c) => !c.key || c.key.find((k) => item.keys.includes(k)));
+                    const converter = device.definition!.toZigbee.find((c) => !c.key || c.key.find((k) => item.keys.includes(k)));
                     const options: KeyValue = device.options;
                     const state = this.state.get(device);
                     const meta: zhc.Tz.Meta = {
                         message: this.state.get(device),
-                        mapped: device.definition,
-                        endpoint_name: null,
+                        mapped: device.definition!,
+                        endpoint_name: undefined,
                         options,
                         state,
                         device: device.zh,
                     };
 
                     try {
-                        await converter?.convertGet?.(device.endpoint(), item.keys[0], meta);
+                        const endpoint = device.endpoint();
+                        assert(endpoint);
+                        await converter?.convertGet?.(endpoint, item.keys[0], meta);
                     } catch (error) {
-                        logger.error(`Failed to read state of '${device.name}' after reconnect (${error.message})`);
+                        logger.error(`Failed to read state of '${device.name}' after reconnect (${(error as Error).message})`);
                     }
 
                     await utils.sleep(500);