iobroker.device-watcher 2.9.10 → 2.9.12

package/main.js

@@ -374,215 +374,27 @@ class DeviceWatcher extends utils.Adapter {
 	async onStateChange(id, state) {
 		if (state) {
 			// this.log.debug(`State changed: ${id} changed ${state.val}`);
-			let batteryData;
-			let signalData;
-			let oldLowBatState;
-			let contactData;
-			let oldStatus;
-			let isLowBatValue;
-			let instanceStatusRaw;
-			let oldAdapterUpdatesCounts;
 
 			try {
 				/*=============================================
-				=           	 Adapter Updates      	     =
+				=        	Instances / Adapter     	     =
 				=============================================*/
-				if (id.endsWith('updatesJson')) {
-					oldAdapterUpdatesCounts = this.countAdapterUpdates;
-					await this.getAdapterUpdateData(id);
-					await this.createAdapterUpdateList();
-					if (this.config.checkSendAdapterUpdateMsg && this.countAdapterUpdates > oldAdapterUpdatesCounts) {
-						await this.sendStateNotifications('updateAdapter', null);
+				if (this.config.checkAdapterInstances) {
+					// Adapter Update data
+					if (id.endsWith('updatesJson')) {
+						await this.renewAdapterUpdateData(id);
 					}
-					for (const instance of this.listInstanceRaw.values()) {
-						if (this.adapterUpdatesJsonRaw.has(instance.Adapter)) {
-							for (const adapter of this.adapterUpdatesJsonRaw.values()) {
-								instance.updateAvailable = adapter.newVersion;
-							}
-						} else {
-							instance.updateAvailable = ' - ';
-						}
-					}
-				}
-
-				/*=============================================
-				=       	    	Instances       	     =
-				=============================================*/
-				for (const [instanceID, instanceData] of this.listInstanceRaw) {
-					const checkInstance = async (instanceID, instanceData) => {
-						if (!instanceData.checkIsRunning) {
-							instanceData.checkIsRunning = true;
-							instanceStatusRaw = await this.setInstanceStatus(instanceData.instanceMode, instanceData.schedule, instanceID);
-							instanceData.isAlive = instanceStatusRaw[0];
-							instanceData.isHealthy = instanceStatusRaw[1];
-							instanceData.status = instanceStatusRaw[2];
-							instanceData.checkIsRunning = false;
-							return;
-						}
-					};
-
-					switch (id) {
-						case `system.adapter.${instanceID}.alive`:
-							if (state.val !== instanceData.isAlive) {
-								await checkInstance(instanceID, instanceData);
-								// send message when instance was deactivated
-								if (this.config.checkSendInstanceDeactivatedMsg && !instanceData.isAlive) {
-									if (this.blacklistInstancesNotify.includes(instanceID)) continue;
-									await this.sendStateNotifications('deactivatedInstance', instanceID);
-								}
-							}
-
-							break;
-						case `system.adapter.${instanceID}.connected`:
-							if (state.val !== instanceData.isConnectedHost && instanceData.isAlive) {
-								await checkInstance(instanceID, instanceData);
-								// send message when instance has an error
-								if (this.config.checkSendInstanceFailedMsg && !instanceData.isHealthy && instanceData.isAlive) {
-									if (this.blacklistInstancesNotify.includes(instanceID)) continue;
-									await this.sendStateNotifications('errorInstance', instanceID);
-								}
-							}
-							break;
-						case `${instanceID}.info.connection`:
-							if (state.val !== instanceData.isConnectedDevice && instanceData.isAlive) {
-								await checkInstance(instanceID, instanceData);
-								// send message when instance has an error
-								if (this.config.checkSendInstanceFailedMsg && !instanceData.isHealthy && instanceData.isAlive) {
-									if (this.blacklistInstancesNotify.includes(instanceID)) continue;
-									await this.sendStateNotifications('errorInstance', instanceID);
-								}
-							}
-
-							break;
+					// Instanz data
+					if (Array.from(this.listInstanceRaw.values()).some((obj) => Object.values(obj).includes(id))) {
+						await this.renewInstanceData(id, state);
 					}
 				}
 
 				/*=============================================
 				=          		  Devices     			      =
 				=============================================*/
-				for (const [device, deviceData] of this.listAllDevicesRaw) {
-					// On statechange update available datapoint
-					switch (id) {
-						// device connection
-						case deviceData.instanceDeviceConnectionDP:
-							if (state.val !== deviceData.instancedeviceConnected) {
-								deviceData.instancedeviceConnected = state.val;
-							}
-							break;
-
-						// device updates
-						case deviceData.UpdateDP:
-							if (state.val !== deviceData.Upgradable) {
-								deviceData.Upgradable = await this.checkDeviceUpdate(deviceData.adapterID, state.val);
-								if (deviceData.Upgradable === true) {
-									if (this.config.checkSendDeviceUpgrade && !this.blacklistNotify.includes(deviceData.Path)) {
-										await this.sendStateNotifications('updateDevice', device);
-									}
-								}
-							}
-							break;
-
-						// device signal
-						case deviceData.SignalStrengthDP:
-							signalData = await this.calculateSignalStrength(state, deviceData.adapterID);
-							deviceData.SignalStrength = signalData[0];
-
-							break;
-
-						// device battery
-						case deviceData.batteryDP:
-							if (deviceData.isBatteryDevice) {
-								oldLowBatState = deviceData.LowBat;
-								if (state.val === 0 && deviceData.BatteryRaw >= 5) continue;
-								batteryData = await this.getBatteryData(state.val, oldLowBatState, deviceData.faultReport, deviceData.adapterID);
-
-								deviceData.Battery = batteryData[0];
-								deviceData.BatteryRaw = batteryData[2];
-								deviceData.BatteryUnitRaw = batteryData[3];
-								if (deviceData.LowBatDP !== 'none') {
-									isLowBatValue = await this.getInitValue(deviceData.LowBatDP);
-								} else {
-									isLowBatValue = undefined;
-								}
-								deviceData.LowBat = await this.setLowbatIndicator(state.val, isLowBatValue, deviceData.faultReport, deviceData.adapterID);
-
-								if (deviceData.LowBat && oldLowBatState !== deviceData.LowBat) {
-									if (this.config.checkSendBatteryMsg && !this.blacklistNotify.includes(deviceData.Path)) {
-										await this.sendStateNotifications('lowBatDevice', device);
-									}
-								}
-							}
-							break;
-
-						// device low bat
-						case deviceData.LowBatDP:
-							if (deviceData.isBatteryDevice) {
-								oldLowBatState = deviceData.LowBat;
-								batteryData = await this.getBatteryData(deviceData.BatteryRaw, state.val, deviceData.faultReport, deviceData.adapterID);
-								deviceData.Battery = batteryData[0];
-								deviceData.BatteryRaw = batteryData[2];
-								deviceData.BatteryUnitRaw = batteryData[3];
-								deviceData.LowBat = await this.setLowbatIndicator(deviceData.BatteryRaw, state.val, deviceData.faultReport, deviceData.adapterID);
-
-								if (deviceData.LowBat && oldLowBatState !== deviceData.LowBat) {
-									if (this.config.checkSendBatteryMsg && !this.blacklistNotify.includes(deviceData.Path)) {
-										await this.sendStateNotifications('lowBatDevice', device);
-									}
-								}
-							}
-							break;
-
-						//device error / fault reports
-						case deviceData.faultReportDP:
-							if (deviceData.isBatteryDevice) {
-								oldLowBatState = deviceData.LowBat;
-								batteryData = await this.getBatteryData(deviceData.BatteryRaw, oldLowBatState, state.val, deviceData.adapterID);
-
-								deviceData.Battery = batteryData[0];
-								deviceData.BatteryRaw = batteryData[2];
-								deviceData.BatteryUnitRaw = batteryData[3];
-								deviceData.LowBat = await this.setLowbatIndicator(deviceData.BatteryRaw, undefined, state.val, deviceData.adapterID);
-
-								if (deviceData.LowBat && oldLowBatState !== deviceData.LowBat) {
-									if (this.config.checkSendBatteryMsg && !this.blacklistNotify.includes(deviceData.Path)) {
-										await this.sendStateNotifications('lowBatDevice', device);
-									}
-								}
-							}
-							break;
-
-						// device unreach
-						case deviceData.UnreachDP:
-							if (deviceData.UnreachState !== state.val) {
-								oldStatus = deviceData.Status;
-								deviceData.UnreachState = state.val;
-								contactData = await this.getOnlineState(
-									deviceData.timeSelector,
-									deviceData.adapterID,
-									deviceData.UnreachDP,
-									deviceData.SignalStrength,
-									deviceData.UnreachState,
-									deviceData.DeviceStateSelectorDP,
-									deviceData.rssiPeerSelectorDP,
-								);
-								if (contactData !== undefined) {
-									deviceData.LastContact = contactData[0];
-									deviceData.Status = contactData[1];
-									deviceData.SignalStrength = contactData[2];
-								}
-								if (this.config.checkSendOfflineMsg && oldStatus !== deviceData.Status && !this.blacklistNotify.includes(deviceData.Path)) {
-									if (deviceData.instanceDeviceConnectionDP.val !== undefined) {
-										// check if the generally deviceData connected state is for a while true
-										if (await this.getTimestampConnectionDP(deviceData.instanceDeviceConnectionDP, 20000)) {
-											await this.sendStateNotifications('onlineStateDevice', device);
-										}
-									} else {
-										await this.sendStateNotifications('onlineStateDevice', device);
-									}
-								}
-							}
-							break;
-					}
+				if (Array.from(this.listAllDevicesRaw.values()).some((obj) => Object.values(obj).includes(id))) {
+					await this.renewDeviceData(id, state);
 				}
 			} catch (error) {
 				this.log.error(`Issue at state change: ${error}`);
@@ -864,9 +676,9 @@ class DeviceWatcher extends utils.Adapter {
 
 				const instanceDeviceConnectionDP = `${instance}.info.connection`;
 				const instancedeviceConnected = await this.getInitValue(instanceDeviceConnectionDP);
-				this.subscribeForeignStates(instanceDeviceConnectionDP);
-				this.subscribeForeignObjects(`${this.selAdapter[i].Selektor}`);
-
+				// this.subscribeForeignStates(instanceDeviceConnectionDP);
+				//this.subscribeForeignObjects(`${this.selAdapter[i].Selektor}`);
+				this.subscribeForeignObjects('*');
 				/*=============================================
 				=              Get device name		          =
 				=============================================*/
@@ -884,7 +696,7 @@ class DeviceWatcher extends utils.Adapter {
 				const shortCurrDeviceString = currDeviceString.slice(0, currDeviceString.lastIndexOf('.') + 1 - 1);
 
 				// subscribe to object device path
-				this.subscribeForeignObjects(currDeviceString);
+				// this.subscribeForeignStates(currDeviceString);
 
 				/*=============================================
 				=            Get signal strength              =
@@ -911,7 +723,7 @@ class DeviceWatcher extends utils.Adapter {
 						break;
 				}
 				//subscribe to states
-				this.subscribeForeignStates(deviceQualityDP);
+				// this.subscribeForeignStates(deviceQualityDP);
 
 				const signalData = await this.calculateSignalStrength(deviceQualityState, adapterID);
 				let linkQuality = signalData[0];
@@ -983,9 +795,9 @@ class DeviceWatcher extends utils.Adapter {
 					faultReportingState = await this.getInitValue(faultReportingDP);
 
 					//subscribe to states
-					this.subscribeForeignStates(deviceBatteryStateDP);
-					this.subscribeForeignStates(isLowBatDP);
-					this.subscribeForeignStates(faultReportingDP);
+					// this.subscribeForeignStates(deviceBatteryStateDP);
+					// this.subscribeForeignStates(isLowBatDP);
+					// this.subscribeForeignStates(faultReportingDP);
 
 					const batteryData = await this.getBatteryData(deviceBatteryState, deviceLowBatState, faultReportingState, adapterID);
 					batteryHealth = batteryData[0];
@@ -1018,10 +830,10 @@ class DeviceWatcher extends utils.Adapter {
 				}
 
 				// subscribe to states
-				this.subscribeForeignStates(timeSelector);
-				this.subscribeForeignStates(unreachDP);
-				this.subscribeForeignStates(deviceStateSelectorDP);
-				this.subscribeForeignStates(rssiPeerSelectorDP);
+				// this.subscribeForeignStates(timeSelector);
+				// this.subscribeForeignStates(unreachDP);
+				// this.subscribeForeignStates(deviceStateSelectorDP);
+				// this.subscribeForeignStates(rssiPeerSelectorDP);
 
 				const onlineState = await this.getOnlineState(timeSelector, adapterID, unreachDP, linkQuality, deviceUnreachState, deviceStateSelectorDP, rssiPeerSelectorDP);
 				let deviceState;
@@ -1059,7 +871,8 @@ class DeviceWatcher extends utils.Adapter {
 					}
 
 					// subscribe to states
-					this.subscribeForeignStates(deviceUpdateDP);
+					// this.subscribeForeignStates(deviceUpdateDP);
+					this.subscribeForeignStates('*');
 				}
 
 				/*=============================================
@@ -1173,6 +986,7 @@ class DeviceWatcher extends utils.Adapter {
 				//Get ID of foldername
 				case 'tado':
 				case 'wifilight':
+				case 'fullybrowserV3':
 					deviceName = currDeviceString.slice(currDeviceString.lastIndexOf('.') + 1);
 					break;
 
@@ -2042,6 +1856,146 @@ class DeviceWatcher extends utils.Adapter {
 		this.log.debug(`Function finished: ${this.writeDatapoints.name}`);
 	} //<--End  of writing Datapoints
 
+	/**
+	 * @param {string | string[]} id
+	 * @param {ioBroker.State} state
+	 */
+	async renewDeviceData(id, state) {
+		let batteryData;
+		let signalData;
+		let oldLowBatState;
+		let contactData;
+		let oldStatus;
+		let isLowBatValue;
+
+		const deviceID = id.slice(0, id.lastIndexOf('.') + 1 - 1);
+		const deviceData = this.listAllDevicesRaw.get(deviceID);
+
+		if (deviceData) {
+			// On statechange update available datapoint
+			switch (id) {
+				// device connection
+				case deviceData.instanceDeviceConnectionDP:
+					if (state.val !== deviceData.instancedeviceConnected) {
+						deviceData.instancedeviceConnected = state.val;
+					}
+					break;
+
+				// device updates
+				case deviceData.UpdateDP:
+					if (state.val !== deviceData.Upgradable) {
+						deviceData.Upgradable = await this.checkDeviceUpdate(deviceData.adapterID, state.val);
+						if (deviceData.Upgradable === true) {
+							if (this.config.checkSendDeviceUpgrade && !this.blacklistNotify.includes(deviceData.Path)) {
+								await this.sendStateNotifications('updateDevice', deviceID);
+							}
+						}
+					}
+					break;
+
+				// device signal
+				case deviceData.SignalStrengthDP:
+					signalData = await this.calculateSignalStrength(state, deviceData.adapterID);
+					deviceData.SignalStrength = signalData[0];
+
+					break;
+
+				// device battery
+				case deviceData.batteryDP:
+					if (deviceData.isBatteryDevice) {
+						oldLowBatState = deviceData.LowBat;
+						if (state.val === 0 && deviceData.BatteryRaw >= 5) return;
+						batteryData = await this.getBatteryData(state.val, oldLowBatState, deviceData.faultReport, deviceData.adapterID);
+
+						deviceData.Battery = batteryData[0];
+						deviceData.BatteryRaw = batteryData[2];
+						deviceData.BatteryUnitRaw = batteryData[3];
+						if (deviceData.LowBatDP !== 'none') {
+							isLowBatValue = await this.getInitValue(deviceData.LowBatDP);
+						} else {
+							isLowBatValue = undefined;
+						}
+						deviceData.LowBat = await this.setLowbatIndicator(state.val, isLowBatValue, deviceData.faultReport, deviceData.adapterID);
+
+						if (deviceData.LowBat && oldLowBatState !== deviceData.LowBat) {
+							if (this.config.checkSendBatteryMsg && !this.blacklistNotify.includes(deviceData.Path)) {
+								await this.sendStateNotifications('lowBatDevice', deviceID);
+							}
+						}
+					}
+					break;
+
+				// device low bat
+				case deviceData.LowBatDP:
+					if (deviceData.isBatteryDevice) {
+						oldLowBatState = deviceData.LowBat;
+						batteryData = await this.getBatteryData(deviceData.BatteryRaw, state.val, deviceData.faultReport, deviceData.adapterID);
+						deviceData.Battery = batteryData[0];
+						deviceData.BatteryRaw = batteryData[2];
+						deviceData.BatteryUnitRaw = batteryData[3];
+						deviceData.LowBat = await this.setLowbatIndicator(deviceData.BatteryRaw, state.val, deviceData.faultReport, deviceData.adapterID);
+
+						if (deviceData.LowBat && oldLowBatState !== deviceData.LowBat) {
+							if (this.config.checkSendBatteryMsg && !this.blacklistNotify.includes(deviceData.Path)) {
+								await this.sendStateNotifications('lowBatDevice', deviceID);
+							}
+						}
+					}
+					break;
+
+				//device error / fault reports
+				case deviceData.faultReportDP:
+					if (deviceData.isBatteryDevice) {
+						oldLowBatState = deviceData.LowBat;
+						batteryData = await this.getBatteryData(deviceData.BatteryRaw, oldLowBatState, state.val, deviceData.adapterID);
+
+						deviceData.Battery = batteryData[0];
+						deviceData.BatteryRaw = batteryData[2];
+						deviceData.BatteryUnitRaw = batteryData[3];
+						deviceData.LowBat = await this.setLowbatIndicator(deviceData.BatteryRaw, undefined, state.val, deviceData.adapterID);
+
+						if (deviceData.LowBat && oldLowBatState !== deviceData.LowBat) {
+							if (this.config.checkSendBatteryMsg && !this.blacklistNotify.includes(deviceData.Path)) {
+								await this.sendStateNotifications('lowBatDevice', deviceID);
+							}
+						}
+					}
+					break;
+
+				// device unreach
+				case deviceData.UnreachDP:
+					if (deviceData.UnreachState !== state.val) {
+						oldStatus = deviceData.Status;
+						deviceData.UnreachState = state.val;
+						contactData = await this.getOnlineState(
+							deviceData.timeSelector,
+							deviceData.adapterID,
+							deviceData.UnreachDP,
+							deviceData.SignalStrength,
+							deviceData.UnreachState,
+							deviceData.DeviceStateSelectorDP,
+							deviceData.rssiPeerSelectorDP,
+						);
+						if (contactData !== undefined) {
+							deviceData.LastContact = contactData[0];
+							deviceData.Status = contactData[1];
+							deviceData.SignalStrength = contactData[2];
+						}
+						if (this.config.checkSendOfflineMsg && oldStatus !== deviceData.Status && !this.blacklistNotify.includes(deviceData.Path)) {
+							if (deviceData.instanceDeviceConnectionDP.val !== undefined) {
+								// check if the generally deviceData connected state is for a while true
+								if (await this.getTimestampConnectionDP(deviceData.instanceDeviceConnectionDP, 20000)) {
+									await this.sendStateNotifications('onlineStateDevice', deviceID);
+								}
+							} else {
+								await this.sendStateNotifications('onlineStateDevice', deviceID);
+							}
+						}
+					}
+					break;
+			}
+		}
+	}
 	/**
 	 * get all Instances at start
 	 */
@@ -2126,10 +2080,12 @@ class DeviceWatcher extends utils.Adapter {
 				}
 
 				//subscribe to statechanges
-				this.subscribeForeignStates(id);
-				this.subscribeForeignStates(instanceConnectedHostDP);
-				this.subscribeForeignStates(instanceConnectedDeviceDP);
-				this.subscribeForeignObjects(`system.adapter.*`);
+				// this.subscribeForeignStates(id);
+				// this.subscribeForeignStates(instanceConnectedHostDP);
+				// this.subscribeForeignStates(instanceConnectedDeviceDP);
+				this.subscribeForeignStates('*');
+				//this.subscribeForeignObjects(`system.adapter.*`);
+				this.subscribeForeignObjects('*');
 
 				// create raw list
 				this.listInstanceRaw.set(instanceID, {
@@ -2145,6 +2101,9 @@ class DeviceWatcher extends utils.Adapter {
 					isConnectedDevice: instanceConnectedDeviceVal,
 					status: instanceStatus,
 					checkIsRunning: false,
+					aliveDP: `system.adapter.${instanceID}.alive`,
+					hostConnectionDP: instanceConnectedHostDP,
+					deviceConnectionDP: instanceConnectedDeviceDP,
 				});
 			}
 			await this.createInstanceList();
@@ -2363,7 +2322,7 @@ class DeviceWatcher extends utils.Adapter {
 		const adapterUpdateListDP = `admin.*.info.updatesJson`;
 
 		// subscribe to datapoint
-		this.subscribeForeignStates(adapterUpdateListDP);
+		// this.subscribeForeignStates(adapterUpdateListDP);
 
 		await this.getAdapterUpdateData(adapterUpdateListDP);
 
@@ -2534,6 +2493,81 @@ class DeviceWatcher extends utils.Adapter {
 		await this.setStateChangedAsync(`adapterAndInstances.countInstancesError`, { val: this.countErrorInstance, ack: true });
 	}
 
+	/**
+	 * @param {string} id
+	 */
+	async renewAdapterUpdateData(id) {
+		const oldAdapterUpdatesCounts = this.countAdapterUpdates;
+		await this.getAdapterUpdateData(id);
+		await this.createAdapterUpdateList();
+		if (this.config.checkSendAdapterUpdateMsg && this.countAdapterUpdates > oldAdapterUpdatesCounts) {
+			await this.sendStateNotifications('updateAdapter', null);
+		}
+		this.listInstanceRaw.forEach((instance) => {
+			const adapterUpdate = this.adapterUpdatesJsonRaw.get(instance.Adapter);
+			instance.updateAvailable = adapterUpdate ? adapterUpdate.newVersion : ' - ';
+		});
+	}
+	/**
+	 * call function on state change, renew data and send messages
+	 * @param {string} id
+	 * @param {ioBroker.State} state
+	 */
+	async renewInstanceData(id, state) {
+		const instanceID = await this.getInstanceName(id);
+		const instanceData = this.listInstanceRaw.get(instanceID);
+		if (instanceData) {
+			let instanceStatusRaw;
+
+			const checkInstance = async (instanceID, instanceData) => {
+				if (!instanceData.checkIsRunning) {
+					instanceData.checkIsRunning = true;
+					instanceStatusRaw = await this.setInstanceStatus(instanceData.instanceMode, instanceData.schedule, instanceID);
+					instanceData.isAlive = instanceStatusRaw[0];
+					instanceData.isHealthy = instanceStatusRaw[1];
+					instanceData.status = instanceStatusRaw[2];
+					instanceData.checkIsRunning = false;
+					return;
+				}
+			};
+
+			switch (id) {
+				case `system.adapter.${instanceID}.alive`:
+					if (state.val !== instanceData.isAlive) {
+						await checkInstance(instanceID, instanceData);
+						// send message when instance was deactivated
+						if (this.config.checkSendInstanceDeactivatedMsg && !instanceData.isAlive) {
+							if (this.blacklistInstancesNotify.includes(instanceID)) return;
+							await this.sendStateNotifications('deactivatedInstance', instanceID);
+						}
+					}
+					break;
+
+				case `system.adapter.${instanceID}.connected`:
+					if (state.val !== instanceData.isConnectedHost && instanceData.isAlive) {
+						await checkInstance(instanceID, instanceData);
+						// send message when instance has an error
+						if (this.config.checkSendInstanceFailedMsg && !instanceData.isHealthy && instanceData.isAlive) {
+							if (this.blacklistInstancesNotify.includes(instanceID)) return;
+							await this.sendStateNotifications('errorInstance', instanceID);
+						}
+					}
+					break;
+
+				case `${instanceID}.info.connection`:
+					if (state.val !== instanceData.isConnectedDevice && instanceData.isAlive) {
+						await checkInstance(instanceID, instanceData);
+						// send message when instance has an error
+						if (this.config.checkSendInstanceFailedMsg && !instanceData.isHealthy && instanceData.isAlive) {
+							if (this.blacklistInstancesNotify.includes(instanceID)) return;
+							await this.sendStateNotifications('errorInstance', instanceID);
+						}
+					}
+					break;
+			}
+		}
+	}
+
 	/**
 	 * create Datapoints for Instances
 	 */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "iobroker.device-watcher",
-  "version": "2.9.10",
+  "version": "2.9.12",
   "description": "Watchdog for devices",
   "author": {
     "name": "Christian Behrends",
@@ -37,24 +37,24 @@
     "@types/chai": "^4.3.11",
     "@types/chai-as-promised": "^7.1.8",
     "@types/mocha": "^10.0.6",
-    "@types/node": "^20.10.1",
-    "@types/node-schedule": "^2.1.4",
+    "@types/node": "^20.10.6",
+    "@types/node-schedule": "^2.1.5",
     "@types/proxyquire": "^1.3.31",
     "@types/sinon": "^17.0.2",
     "@types/sinon-chai": "^3.2.12",
     "chai": "^4.3.10",
     "chai-as-promised": "^7.1.1",
     "cron-parser": "^4.9.0",
-    "eslint": "^8.54.0",
-    "eslint-config-prettier": "^9.0.0",
-    "eslint-plugin-prettier": "^5.0.1",
+    "eslint": "^8.56.0",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-plugin-prettier": "^5.1.2",
     "mocha": "^10.2.0",
     "node-schedule": "^2.1.1",
-    "prettier": "^3.1.0",
+    "prettier": "^3.1.1",
     "proxyquire": "^2.1.3",
     "sinon": "^17.0.1",
     "sinon-chai": "^3.7.0",
-    "typescript": "~5.3.2"
+    "typescript": "~5.3.3"
   },
   "main": "main.js",
   "files": [