iobroker.zigbee2mqtt 3.0.10 → 3.0.13

package/lib/rgb.js

@@ -1,4 +1,4 @@
-/* eslint-disable no-prototype-builtins */
+ 
 /*
 With these functions you can convert the CIE color space to the RGB color space and vice versa.
 
@@ -44,7 +44,11 @@ const colors = require('./colors.js');
 
 /**
  * Converts CIE color space to RGB color space
- * @return {Array} Array that contains the color values for red, green and blue
+ *
+ * @param x
+ * @param y
+ * @param brightness
+ * @returns {Array} Array that contains the color values for red, green and blue
  */
 function cie_to_rgb(x, y, brightness) {
     //Set to maximum brightness if no custom value was given (Not the slick ECMAScript 6 way for compatibility reasons)
@@ -54,17 +58,17 @@ function cie_to_rgb(x, y, brightness) {
 
     const z = 1.0 - x - y;
     const Y = (brightness / 254).toFixed(2);
-    // @ts-ignore
+    
     const X = (Y / y) * x;
-    // @ts-ignore
+    
     const Z = (Y / y) * z;
 
     //Convert to RGB using Wide RGB D65 conversion
-    // @ts-ignore
+    
     let red = X * 1.656492 - Y * 0.354851 - Z * 0.255038;
-    // @ts-ignore
+    
     let green = -X * 0.707196 + Y * 1.655397 + Z * 0.036152;
-    // @ts-ignore
+    
     let blue = X * 0.051713 - Y * 0.121364 + Z * 1.01153;
 
     //If red, green or blue is larger than 1.0 set it back to the maximum of 1.0
@@ -109,10 +113,11 @@ function cie_to_rgb(x, y, brightness) {
 
 /**
  * Converts RGB color space to CIE color space
- * @param {Number} red
- * @param {Number} green
- * @param {Number} blue
- * @return {Array} Array that contains the CIE color values for x and y
+ *
+ * @param {number} red
+ * @param {number} green
+ * @param {number} blue
+ * @returns {Array} Array that contains the CIE color values for x and y
  */
 function rgb_to_cie(red, green, blue) {
     // Apply a gamma correction to the RGB values, which makes the color more vivid and more the like the color displayed on the screen of your device
@@ -129,21 +134,27 @@ function rgb_to_cie(red, green, blue) {
     let x = (X / (X + Y + Z)).toFixed(4);
     let y = (Y / (X + Y + Z)).toFixed(4);
 
-    // @ts-ignore
+    
     if (isNaN(x)) {
-        // @ts-ignore
+        
         x = 0;
     }
 
-    // @ts-ignore
+    
     if (isNaN(y)) {
-        // @ts-ignore
+        
         y = 0;
     }
 
     return [x, y];
 }
 
+/**
+ *
+ * @param h
+ * @param s
+ * @param v
+ */
 function hsvToRGB(h, s, v) {
     h = (h % 360) / 360;
     s = s / 100;
@@ -187,6 +198,13 @@ function hsvToRGB(h, s, v) {
     };
 }
 
+/**
+ *
+ * @param r
+ * @param g
+ * @param b
+ * @param numeric
+ */
 function rgbToHSV(r, g, b, numeric) {
     if (arguments.length === 1) {
         (g = r.g), (b = r.b), (r = r.r);
@@ -215,21 +233,26 @@ function rgbToHSV(r, g, b, numeric) {
             h /= 6 * d;
             break;
     }
-    if (numeric)
-        return {
-            // @ts-ignore
+    if (numeric) {
+return {
+            
             h: Math.round(h * 360),
             s: Math.round(s * 100),
             v: Math.round(v * 100),
         };
+}
     return {
-        // @ts-ignore
+        
         h: (h * 360).toFixed(3),
         s: (s * 100).toFixed(3),
         v: (v * 100).toFixed(3),
     };
 }
 
+/**
+ *
+ * @param value
+ */
 function colorArrayFromString(value) {
     if (typeof value === 'string') {
         const rv = [];
@@ -241,6 +264,10 @@ function colorArrayFromString(value) {
     return [{ r: 0, g: 128, b: 255 }];
 }
 
+/**
+ *
+ * @param payload
+ */
 function colorStringFromRGBArray(payload) {
     const rv = [];
     payload.forEach((element) => {
@@ -249,6 +276,12 @@ function colorStringFromRGBArray(payload) {
     return rv.toString();
 }
 
+/**
+ *
+ * @param h
+ * @param s
+ * @param v
+ */
 function hsv_to_cie(h, s, v) {
     const rgb = hsvToRGB(h, s, v);
     return rgb_to_cie(rgb.r, rgb.g, rgb.b);
@@ -256,20 +289,35 @@ function hsv_to_cie(h, s, v) {
 
 function rgb_to_rgbstring(element) {
     let col = '#';
-    if (element && element.hasOwnProperty('r')) col = col + element.r.toString(16).padStart(2, '0');
-    else col = col + '00';
-    if (element && element.hasOwnProperty('g')) col = col + element.g.toString(16).padStart(2, '0');
-    else col = col + '00';
-    if (element && element.hasOwnProperty('b')) col = col + element.b.toString(16).padStart(2, '0');
-    else col = col + '00';
+    if (element && element.hasOwnProperty('r')) {
+col = col + element.r.toString(16).padStart(2, '0');
+} else {
+col = `${col  }00`;
+}
+    if (element && element.hasOwnProperty('g')) {
+col = col + element.g.toString(16).padStart(2, '0');
+} else {
+col = `${col  }00`;
+}
+    if (element && element.hasOwnProperty('b')) {
+col = col + element.b.toString(16).padStart(2, '0');
+} else {
+col = `${col  }00`;
+}
     return col;
 }
 
+/**
+ *
+ * @param h
+ * @param s
+ * @param b
+ */
 function hsbToRGB(h, s, b) {
     const br = Math.round(b * 2.55);
     if (s == 0) {
         return [br, br, br];
-    } else {
+    } 
         const hue = h % 360;
         const f = hue % 60;
         const p = Math.round(b * (100 - s) * 0.0255);
@@ -289,10 +337,16 @@ function hsbToRGB(h, s, b) {
             case 5:
                 return [br, p, q];
         }
-    }
+    
     return false;
 }
 
+/**
+ *
+ * @param h
+ * @param s
+ * @param v
+ */
 function hsvToRGBString(h, s, v) {
     return rgb_to_rgbstring(hsvToRGB(h, s, v));
 }

package/lib/statesController.js

@@ -2,7 +2,18 @@ const utils = require('./utils');
 const incStatsQueue = [];
 const timeOutCache = {};
 
+/**
+ *
+ */
 class StatesController {
+    /**
+     *
+     * @param adapter
+     * @param deviceCache
+     * @param groupCache
+     * @param logCustomizations
+     * @param createCache
+     */
     constructor(adapter, deviceCache, groupCache, logCustomizations, createCache) {
         this.adapter = adapter;
         this.groupCache = groupCache;
@@ -11,6 +22,10 @@ class StatesController {
         this.createCache = createCache;
     }
 
+    /**
+     *
+     * @param messageObj
+     */
     processDeviceMessage(messageObj) {
         // Is payload present?
         if (messageObj.payload == '') {
@@ -30,6 +45,11 @@ class StatesController {
         }
     }
 
+    /**
+     *
+     * @param messageObj
+     * @param device
+     */
     async setDeviceStateSafely(messageObj, device) {
         if (this.logCustomizations.debugDevices.includes(device.ieee_address)) {
             this.adapter.log.warn(`--->>> fromZ2M -> ${device.ieee_address} states: ${JSON.stringify(messageObj)}`);
@@ -103,19 +123,15 @@ class StatesController {
                     //  Is an action
                     if (state.prop && state.prop == 'action') {
                         actionStates.push(state);
-                    }
-                    // Is not an action
+                    } else if (
+                     // Is not an action
                     // check if its a motion sensor (occupancy state) and if configuration is set to update state every time
                     // if yes, use setStateSafelyAsync instead of setStateChangedSafelyAsync
-                    else if (
-                        this.adapter.config.allwaysUpdateOccupancyState === true &&
-						state.id === 'occupancy' &&
-						value === true
+                        this.adapter.config.allwaysUpdateOccupancyState === true &&	state.id === 'occupancy' &&	value === true
                     ) {
                         await this.setStateSafelyAsync(stateName, value);
-                    }
-                    // end section for motion sensor update
-                    else {
+                    } else {
+                     // end section for motion sensor update
                         if (state.getter) {
                             await this.setStateChangedSafelyAsync(stateName, state.getter(messageObj.payload));
                         } else {
@@ -134,11 +150,17 @@ class StatesController {
 
             try {
                 if (state.isEvent && state.isEvent == true) {
+                    const gettr = state.getter(messageObj.payload);
                     if (state.type == 'boolean') {
-                        await this.setStateWithTimeoutAsync(stateName, state.getter(messageObj.payload), 450);
+                        await this.setStateWithTimeoutAsync(stateName, gettr, 450);
                     } else {
-                        await this.setStateSafelyAsync(stateName, state.getter(messageObj.payload));
+                        await this.setStateSafelyAsync(stateName, gettr);
                     }
+                    // publish the action into action dp
+                    if (state.prop && state.prop == 'action') {
+                        await this.setStateSafelyAsync(`${device.ieee_address}.action`, messageObj.payload.action);
+                    }
+
                 } else {
                     await this.setStateChangedSafelyAsync(stateName, state.getter(messageObj.payload));
                 }
@@ -149,6 +171,11 @@ class StatesController {
         }
     }
 
+    /**
+     *
+     * @param stateName
+     * @param value
+     */
     async setStateSafelyAsync(stateName, value) {
         if (value === undefined || value === null) {
             return;
@@ -156,6 +183,11 @@ class StatesController {
         await this.adapter.setStateAsync(stateName, value, true);
     }
 
+    /**
+     *
+     * @param stateName
+     * @param value
+     */
     async setStateChangedSafelyAsync(stateName, value) {
         if (value === undefined || value === null) {
             return;
@@ -163,6 +195,12 @@ class StatesController {
         await this.adapter.setStateChangedAsync(stateName, value, true);
     }
 
+    /**
+     *
+     * @param stateName
+     * @param value
+     * @param timeout
+     */
     async setStateWithTimeoutAsync(stateName, value, timeout) {
         if (value === undefined || value === null) {
             return;
@@ -174,9 +212,13 @@ class StatesController {
         }
         timeOutCache[stateName] = setTimeout(() => {
             this.adapter.setStateAsync(stateName, !value, true);
+
         }, timeout);
     }
 
+    /**
+     *
+     */
     processQueue() {
         const oldIncStatsQueue = [];
         utils.moveArray(incStatsQueue, oldIncStatsQueue);
@@ -185,6 +227,9 @@ class StatesController {
         }
     }
 
+    /**
+     *
+     */
     async subscribeWritableStates() {
         await this.adapter.unsubscribeObjectsAsync('*');
         for (const device of this.groupCache.concat(this.deviceCache)) {
@@ -199,6 +244,9 @@ class StatesController {
         this.adapter.subscribeStates('info.coordinator_check');
     }
 
+    /**
+     *
+     */
     async setAllAvailableToFalse() {
         const availableStates = await this.adapter.getStatesAsync('*.available');
         for (const availableState in availableStates) {
@@ -206,6 +254,9 @@ class StatesController {
         }
     }
 
+    /**
+     *
+     */
     async allTimerClear() {
         for (const timer in timeOutCache) {
             clearTimeout(timeOutCache[timer]);

package/lib/utils.js

@@ -1,5 +1,7 @@
 /**
  * Converts a bulb level of range [0...254] to an adapter level of range [0...100]
+ *
+ * @param bulbLevel
  */
 function bulbLevelToAdapterLevel(bulbLevel) {
     // Convert from bulb levels [0...254] to adapter levels [0...100]:
@@ -19,14 +21,16 @@ function bulbLevelToAdapterLevel(bulbLevel) {
     if (bulbLevel >= 2) {
         // Perform linear mapping of range [2...254] to [1...100]
         return Math.round(((bulbLevel - 2) * 99) / 252) + 1;
-    } else {
+    } 
         // The bulb is considered off. Even a bulb level of "1" is considered as off.
         return 0;
-    } // else
+     // else
 }
 
 /**
  * Converts an adapter level of range [0...100] to a bulb level of range [0...254]
+ *
+ * @param adapterLevel
  */
 function adapterLevelToBulbLevel(adapterLevel) {
     // Convert from adapter levels [0...100] to bulb levels [0...254].
@@ -35,13 +39,17 @@ function adapterLevelToBulbLevel(adapterLevel) {
     if (adapterLevel) {
         // Perform linear mapping of range [1...100] to [2...254]
         return Math.round(((adapterLevel - 1) * 252) / 99) + 2;
-    } else {
+    } 
         // Switch the bulb off. Some bulbs need "0" (IKEA), others "1" (HUE), and according to the
         // ZigBee docs "1" is the "minimum possible level"... we choose "0" here which seems to work.
         return 0;
-    } // else
+     // else
 }
 
+/**
+ *
+ * @param ba
+ */
 function bytesArrayToWordArray(ba) {
     const wa = [];
     for (let i = 0; i < ba.length; i++) {
@@ -52,6 +60,10 @@ function bytesArrayToWordArray(ba) {
 
 // If the value is greater than 1000, kelvin is assumed.
 // If smaller, it is assumed to be mired.
+/**
+ *
+ * @param t
+ */
 function toMired(t) {
     let miredValue = t;
     if (t > 1000) {
@@ -60,12 +72,19 @@ function toMired(t) {
     return miredValue;
 }
 
+/**
+ *
+ * @param t
+ */
 function miredKelvinConversion(t) {
     return Math.round(1000000 / t);
 }
 
 /**
  * Converts a decimal number to a hex string with zero-padding
+ *
+ * @param decimal
+ * @param padding
  */
 function decimalToHex(decimal, padding) {
     let hex = Number(decimal).toString(16);
@@ -78,32 +97,60 @@ function decimalToHex(decimal, padding) {
     return hex;
 }
 
+/**
+ *
+ * @param adapterDevId
+ */
 function getZbId(adapterDevId) {
     const idx = adapterDevId.indexOf('group');
-    if (idx > 0) return adapterDevId.substr(idx + 6);
-    return '0x' + adapterDevId.split('.')[2];
+    if (idx > 0) {
+return adapterDevId.substr(idx + 6);
+}
+    return `0x${  adapterDevId.split('.')[2]}`;
 }
 
+/**
+ *
+ * @param adapter
+ * @param id
+ */
 function getAdId(adapter, id) {
-    return adapter.namespace + '.' + id.split('.')[2]; // iobroker device id
+    return `${adapter.namespace  }.${  id.split('.')[2]}`; // iobroker device id
 }
 
+/**
+ *
+ * @param array
+ */
 function clearArray(array) {
     while (array.length > 0) {
         array.pop();
     }
 }
 
+/**
+ *
+ * @param source
+ * @param target
+ */
 function moveArray(source, target) {
     while (source.length > 0) {
         target.push(source.shift());
     }
 }
 
+/**
+ *
+ * @param item
+ */
 function isObject(item) {
     return typeof item === 'object' && !Array.isArray(item) && item !== null;
 }
 
+/**
+ *
+ * @param item
+ */
 function isJson(item) {
     let value = typeof item !== 'string' ? JSON.stringify(item) : item;
     try {

package/lib/websocketController.js

@@ -6,11 +6,21 @@ let ping;
 let pingTimeout;
 let autoRestartTimeout;
 
+/**
+ *
+ */
 class WebsocketController {
+    /**
+     *
+     * @param adapter
+     */
     constructor(adapter) {
         this.adapter = adapter;
     }
 
+    /**
+     *
+     */
     initWsClient() {
         try {
             let wsURL = `${this.adapter.config.wsScheme}://${this.adapter.config.wsServerIP}:${this.adapter.config.wsServerPort}/api`;
@@ -53,6 +63,10 @@ class WebsocketController {
         }
     }
 
+    /**
+     *
+     * @param message
+     */
     send(message) {
         if (wsClient.readyState !== WebSocket.OPEN) {
             this.adapter.log.warn('Cannot set State, no websocket connection to Zigbee2MQTT!');
@@ -61,6 +75,9 @@ class WebsocketController {
         wsClient.send(message);
     }
 
+    /**
+     *
+     */
     sendPingToServer() {
         //this.logDebug('Send ping to server');
         wsClient.ping();
@@ -69,6 +86,9 @@ class WebsocketController {
         }, wsHeartbeatIntervall);
     }
 
+    /**
+     *
+     */
     wsHeartbeat() {
         clearTimeout(pingTimeout);
         pingTimeout = setTimeout(() => {
@@ -77,6 +97,9 @@ class WebsocketController {
         }, wsHeartbeatIntervall + 3000);
     }
 
+    /**
+     *
+     */
     async autoRestart() {
         this.adapter.log.warn(`Start try again in ${restartTimeout / 1000} seconds...`);
         autoRestartTimeout = setTimeout(() => {
@@ -84,12 +107,18 @@ class WebsocketController {
         }, restartTimeout);
     }
 
+    /**
+     *
+     */
     closeConnection() {
         if (wsClient && wsClient.readyState !== WebSocket.CLOSED) {
             wsClient.close();
         }
     }
 
+    /**
+     *
+     */
     async allTimerClear() {
         clearTimeout(pingTimeout);
         clearTimeout(ping);

package/lib/z2mController.js

@@ -1,4 +1,14 @@
+/**
+ *
+ */
 class Z2mController {
+    /**
+     *
+     * @param adapter
+     * @param deviceCache
+     * @param groupCache
+     * @param logCustomizations
+     */
     constructor(adapter, deviceCache, groupCache, logCustomizations) {
         this.adapter = adapter;
         this.groupCache = groupCache;
@@ -6,6 +16,11 @@ class Z2mController {
         this.logCustomizations = logCustomizations;
     }
 
+    /**
+     *
+     * @param id
+     * @param state
+     */
     async createZ2MMessage(id, state) {
         const splitedID = id.split('.');
         if (splitedID.length < 4) {
@@ -114,6 +129,10 @@ class Z2mController {
         return controlObj;
     }
 
+    /**
+     *
+     * @param messageObj
+     */
     async proxyZ2MLogs(messageObj) {
         const logMessage = messageObj.payload.message;
         if (this.logCustomizations.logfilter.some((x) => logMessage.includes(x))) {

package/main.js

@@ -68,8 +68,7 @@ class Zigbee2mqtt extends core.Adapter {
         }
 
         const logfilterState = await this.getStateAsync('info.logfilter');
-        if (logfilterState && logfilterState.val) {
-            // @ts-ignore
+        if (logfilterState && logfilterState.val) {            
             logCustomizations.logfilter = String(logfilterState.val)
                 .split(';')
                 .filter((x) => x); // filter removes empty strings here
@@ -111,9 +110,8 @@ class Zigbee2mqtt extends core.Adapter {
                     `mqtt://${this.config.externalMqttServerIP}:${this.config.externalMqttServerPort}`,
                     mqttClientOptions
                 );
-            }
+            } else {
             // Internal MQTT-Server
-            else {
                 mqttServerController = new MqttServerController(this);
                 await mqttServerController.createMQTTServer();
                 await this.delay(1500);
@@ -137,9 +135,8 @@ class Zigbee2mqtt extends core.Adapter {
                 const newMessage = `{"payload":${payload.toString() == '' ? '"null"' : payload.toString()},"topic":"${topic.slice(topic.search('/') + 1)}"}`;
                 this.messageParse(newMessage);
             });
-        }
+        }  else if (this.config.connectionType == 'ws') {
         // Websocket
-        else if (this.config.connectionType == 'ws') {
             if (this.config.wsServerIP == '') {
                 this.log.warn('Please configure the Websoket connection!');
                 return;
@@ -316,9 +313,8 @@ class Zigbee2mqtt extends core.Adapter {
             } catch (e) {
                 this.log.error(e);
             }
-        }
+        } else if (this.config.connectionType == 'ws') {
         // Websocket
-        else if (this.config.connectionType == 'ws') {
             try {
                 if (websocketController) {
                     websocketController.closeConnection();
@@ -352,6 +348,8 @@ class Zigbee2mqtt extends core.Adapter {
             this.log.error(e);
         }
 
+        this.setState('info.connection', false, true);
+
         callback();
     }
 
@@ -382,8 +380,8 @@ class Zigbee2mqtt extends core.Adapter {
 if (require.main !== module) {
     // Export the constructor in compact mode
     /**
-	 * @param {Partial<core.AdapterOptions>} [options={}]
-	 */
+     * @param {Partial<core.AdapterOptions>} [options]
+     */
     module.exports = (options) => new Zigbee2mqtt(options);
 } else {
     // otherwise start the instance directly