node-red-contrib-knx-ultimate 3.3.29 → 3.3.31

package/CHANGELOG.md

@@ -6,7 +6,11 @@
 
 # CHANGELOG
 
-**Version 3.3.29** - April 2025<br/>
+**Version 3.3.31** - April 2025<br/>
+- **BREAKING CHANGE** **!!!!!!!**: node must be >=18.0.0 (needed before was >=16.0.0).**!!!!!!!** **BREAKING CHANGE**<br/>
+- HUE: getting rid of the Eventsource package, due to sleepy connections not recognized.<br/>
+
+**Version 3.3.30** - April 2025<br/>
 - **BREAKING CHANGE** **!!!!!!!**: node must be >=18.0.0 (needed before was >=16.0.0).**!!!!!!!** **BREAKING CHANGE**<br/>
 - HUE: fixed SSE Hue Bridge silent disconnection issue.<br/>
 

package/nodes/hue-config.js

@@ -5,7 +5,7 @@
 /* eslint-disable no-inner-declarations */
 /* eslint-disable max-len */
 const cloneDeep = require("lodash/cloneDeep");
-const HueClass = require("./utils/hueEngine").classHUE;
+//const classHUE = require("./utils/hueEngine").classHUE;
 const hueColorConverter = require("./utils/colorManipulators/hueColorConverter");
 
 
@@ -47,64 +47,67 @@ module.exports = (RED) => {
       try {
         if (node.hueManager !== undefined) await node.hueManager.close();
       } catch (error) { /* empty */ }
-      try {
-        // Init HUE Utility
-        node.hueManager = new HueClass(node.host, node.credentials.username, node.credentials.clientkey, config.bridgeid, node.sysLogger);
-      } catch (error) {
-        node.sysLogger?.error(`Errore hue-config: node.initHUEConnection: ${error.message}`);
-        throw (error)
-      }
-      node.hueManager.on("event", (_event) => {
-        node.nodeClients.forEach((_oClient) => {
-          const oClient = _oClient;
-          try {
-            if (oClient.handleSendHUE !== undefined) oClient.handleSendHUE(_event);
-          } catch (error) {
-            node.sysLogger?.error(`Errore node.hueManager.on(event): ${error.message}`);
+
+      (async () => {
+        try {
+          const { classHUE } = await import('./utils/hueEngine.mjs');
+          node.hueManager = new classHUE(node.host, node.credentials.username, node.credentials.clientkey, config.bridgeid, node.sysLogger);
+        } catch (error) {
+          node.sysLogger?.error(`Errore hue-config: node.initHUEConnection: ${error.message}`);
+          throw (error)
+        }
+        node.hueManager.on("event", (_event) => {
+          node.nodeClients.forEach((_oClient) => {
+            const oClient = _oClient;
+            try {
+              if (oClient.handleSendHUE !== undefined) oClient.handleSendHUE(_event);
+            } catch (error) {
+              node.sysLogger?.error(`Errore node.hueManager.on(event): ${error.message}`);
+            }
+          });
+        });
+        // Connected
+        node.hueManager.on("connected", () => {
+          if (node.linkStatus === "disconnected") {
+            // Start the timer to do initial read.
+            if (node.timerDoInitialRead !== null) clearTimeout(node.timerDoInitialRead);
+            node.timerDoInitialRead = setTimeout(() => {
+              (async () => {
+                try {
+                  node.sysLogger?.info(`HTTP getting resource from HUE bridge : ${node.name}`);
+                  await node.loadResourcesFromHUEBridge();
+                  node.sysLogger?.info(`Total HUE resources count : ${node.hueAllResources.length}`);
+                } catch (error) {
+                  node.nodeClients.forEach((_oClient) => {
+                    setTimeout(() => {
+                      _oClient.setNodeStatusHue({
+                        fill: "red",
+                        shape: "ring",
+                        text: "HUE",
+                        payload: error.message,
+                      });
+                    }, 200);
+                  });
+                }
+              })();
+            }, 10000); // 17/02/2020 Do initial read of all nodes requesting initial read
           }
         });
-      });
-      // Connected
-      node.hueManager.on("connected", () => {
-        if (node.linkStatus === "disconnected") {
-          // Start the timer to do initial read.
-          if (node.timerDoInitialRead !== null) clearTimeout(node.timerDoInitialRead);
-          node.timerDoInitialRead = setTimeout(() => {
-            (async () => {
-              try {
-                node.sysLogger?.info(`HTTP getting resource from HUE bridge : ${node.name}`);
-                await node.loadResourcesFromHUEBridge();
-                node.sysLogger?.info(`Total HUE resources count : ${node.hueAllResources.length}`);
-              } catch (error) {
-                node.nodeClients.forEach((_oClient) => {
-                  setTimeout(() => {
-                    _oClient.setNodeStatusHue({
-                      fill: "red",
-                      shape: "ring",
-                      text: "HUE",
-                      payload: error.message,
-                    });
-                  }, 200);
-                });
-              }
-            })();
-          }, 10000); // 17/02/2020 Do initial read of all nodes requesting initial read
-        }
-      });
 
-      node.hueManager.on("disconnected", () => {
-        node.nodeClients.forEach((_oClient) => {
-          _oClient.setNodeStatusHue({
-            fill: "red",
-            shape: "ring",
-            text: "HUE Disconnected",
-            payload: "",
+        node.hueManager.on("disconnected", () => {
+          node.nodeClients.forEach((_oClient) => {
+            _oClient.setNodeStatusHue({
+              fill: "red",
+              shape: "ring",
+              text: "HUE Disconnected",
+              payload: "",
+            });
           });
         });
-      });
-      try {
-        await node.hueManager.Connect();
-      } catch (error) { }
+        try {
+          await node.hueManager.Connect();
+        } catch (error) { }
+      })();
 
     };
 
@@ -122,12 +125,16 @@ module.exports = (RED) => {
           }
           await node.startWatchdogTimer();
         })();
-      }, 20000);
+      }, 60000);
     };
 
-    (async () => {
-      await node.startWatchdogTimer();
-    })();
+    setTimeout(() => {
+      (async () => {
+        await node.initHUEConnection();
+        node.startWatchdogTimer();
+      })();
+    }, 5000);
+
 
     // Functions called from the nodes ----------------------------------------------------------------
     // Query the HUE Bridge to return the resources

package/nodes/utils/HueEventStream.mjs

@@ -0,0 +1,100 @@
+import { EventEmitter } from 'events';
+import { fetch, Agent } from 'undici';
+import { setTimeout as delay } from 'timers/promises';
+
+class HueEventStream extends EventEmitter {
+  constructor(url, { headers = {}, reconnectInterval = 5000 } = {}) {
+    super();
+    this.url = url;
+    this.headers = headers;
+    this.reconnectInterval = reconnectInterval;
+    this.abortController = null;
+    this.agent = new Agent({
+      connect: {
+        rejectUnauthorized: false
+      }
+    });
+    this.connected = false;
+    this._start();
+  }
+
+  async _start() {
+    while (true) {
+      try {
+        this.abortController = new AbortController();
+        const res = await fetch(this.url, {
+          headers: this.headers,
+          dispatcher: this.agent,
+          signal: this.abortController.signal
+        });
+
+        if (res.status !== 200) {
+          this.emit('error', new Error(`Unexpected status: ${res.status}`));
+          await delay(this.reconnectInterval);
+          continue;
+        }
+
+        this.emit('open');
+        this.connected = true;
+
+        let buffer = '';
+        for await (const chunk of res.body) {
+          buffer += chunk.toString();
+
+          const lines = buffer.split(/\r?\n\r?\n/);
+          buffer = lines.pop(); // l'ultima parte potrebbe essere incompleta
+
+          for (const block of lines) {
+            const event = this._parseEvent(block);
+            if (event) this.emit('message', event);
+          }
+        }
+
+        this.emit('close');
+        this.connected = false;
+        await delay(this.reconnectInterval);
+      } catch (err) {
+        if (err.name !== 'AbortError') {
+          this.emit('error', err);
+          await delay(this.reconnectInterval);
+        }
+      }
+    }
+  }
+
+  _parseEvent(block) {
+    const lines = block.split(/\r?\n/);
+    let data = '';
+    let event = 'message';
+
+    for (const line of lines) {
+      if (line.startsWith('data:')) {
+        data += line.slice(5).trim();
+      } else if (line.startsWith('event:')) {
+        event = line.slice(6).trim();
+      }
+    }
+
+    try {
+      return {
+        type: event,
+        data: data ? JSON.parse(data) : null
+      };
+    } catch (e) {
+      return {
+        type: event,
+        data: data || null
+      };
+    }
+  }
+
+  close() {
+    if (this.abortController) {
+      this.abortController.abort();
+      this.abortController = null;
+    }
+    this.connected = false;
+  }
+}
+
+export { HueEventStream };

package/nodes/utils/hueEngine.mjs

@@ -0,0 +1,213 @@
+import { EventEmitter } from 'events';
+import { fetch, Agent } from 'undici';
+import { setTimeout as pleaseWait } from 'timers/promises';
+import * as http from './http.js';
+
+class classHUE extends EventEmitter {
+  constructor(_hueBridgeIP, _username, _clientkey, _bridgeid, _sysLogger) {
+    super();
+    this.HUEBridgeConnectionStatus = "disconnected";
+    this.exitAllQueues = false;
+    this.hueBridgeIP = _hueBridgeIP;
+    this.username = _username;
+    this.clientkey = _clientkey;
+    this.bridgeid = _bridgeid;
+    this.commandQueue = [];
+    this.sysLogger = _sysLogger;
+    this.timerCheckConnected = null;
+    this.restartSSECounter = 0;
+    this.handleQueue();
+    this.eventStreamAbort = null;
+  }
+
+  Connect = async () => {
+    if (this.timerCheckConnected !== null) clearInterval(this.timerCheckConnected);
+    if (this.eventStreamAbort) this.eventStreamAbort.abort();
+
+    this.hueApiV2 = http.use({
+      key: this.username,
+      prefix: `https://${this.hueBridgeIP}/clip/v2`
+    });
+
+    const agent = new Agent({
+      connect: { rejectUnauthorized: false }
+    });
+
+    const headers = {
+      'hue-application-key': this.username,
+      'Accept': 'text/event-stream',
+      'Cache-control': 'no-cache'
+    };
+
+    this.eventStreamAbort = new AbortController();
+
+    const url = `https://${this.hueBridgeIP}/eventstream/clip/v2`;
+
+    try {
+      const res = await fetch(url, {
+        headers,
+        dispatcher: agent,
+        signal: this.eventStreamAbort.signal
+      });
+
+      if (res.status !== 200) {
+        this.emit('error', new Error(`Status ${res.status}`));
+        return;
+      }
+
+      this.emit("connected");
+      this.HUEBridgeConnectionStatus = "connected";
+      this.sysLogger?.info(`classHUE: connected to SSE`);
+
+      this.timerCheckConnected = setInterval(() => {
+        (async () => {
+          try {
+            this.restartSSECounter += 1;
+            if (this.restartSSECounter >= 2) {
+              this.sysLogger?.debug(`Restarted SSE Client, per sicurezza, altrimenti potrebbe addormentarsi`);
+              this.restartSSECounter = 0;
+              this.eventStreamAbort.abort();
+              await this.Connect();
+              return;
+            }
+            const jReturn = await this.hueApiV2.get('/resource/bridge');
+            if (!Array.isArray(jReturn) || jReturn.length < 1) throw new Error("Bridge not found");
+            this.HUEBridgeConnectionStatus = "connected";
+          } catch (error) {
+            this.sysLogger?.error(`Ping ERROR: ${error.message}`);
+            if (this.timerCheckConnected !== null) clearInterval(this.timerCheckConnected);
+            this.commandQueue = [];
+            try { await this.close(); } catch (error) { }
+            this.restartSSECounter = 0;
+            this.emit("disconnected");
+          }
+        })();
+      }, 12000);
+
+      let buffer = '';
+      const textDecoder = new TextDecoder();
+      for await (const chunk of res.body) {
+        buffer += textDecoder.decode(chunk, { stream: true });
+        let parts = buffer.split(/\r?\n\r?\n/);
+        if (parts.length > 1) {
+          buffer = parts.pop();
+        } else {
+          buffer = parts[0];
+          parts = [];
+        }
+
+        for (const block of parts) {
+          const parsed = this._parseEvent(block);
+          if (parsed?.data && Array.isArray(parsed.data)) {
+            parsed.data.forEach(ev => {
+              for (let index = 0; index < ev.data.length; index++) {
+                const element = ev.data[index];
+                this.emit("event", element)
+              }
+            });
+          }
+        }
+      }
+    } catch (err) {
+      if (err.name !== 'AbortError' && this.sysLogger) {
+        this.sysLogger.error(`EventStream error: ${err.message}`)
+        this.commandQueue = [];
+        try { await this.close(); } catch (error) { }
+        this.restartSSECounter = 0;
+        this.emit("disconnected");
+      };
+    }
+  };
+
+  _parseEvent = (block) => {
+    const lines = block.split(/\r?\n/);
+    let data = '';
+    let event = 'message';
+
+    for (const line of lines) {
+      if (line.startsWith('data:')) {
+        data += line.slice(5).trim();
+      } else if (line.startsWith('event:')) {
+        event = line.slice(6).trim();
+      }
+    }
+
+    try {
+      return {
+        type: event,
+        data: data ? JSON.parse(data) : null
+      };
+    } catch (e) {
+      return {
+        type: event,
+        data: data || null
+      };
+    }
+  };
+
+  processQueueItem = async () => {
+    try {
+      const jRet = this.commandQueue.pop();
+      switch (jRet._operation) {
+        case "setLight":
+          await this.hueApiV2.put(`/resource/light/${jRet._lightID}`, jRet._state);
+          break;
+        case "setGroupedLight":
+          await this.hueApiV2.put(`/resource/grouped_light/${jRet._lightID}`, jRet._state);
+          break;
+        case "setScene":
+          await this.hueApiV2.put(`/resource/scene/${jRet._lightID}`, jRet._state);
+          break;
+        case "stopScene":
+          const allResources = await this.hueApiV2.get("/resource");
+          const jScene = allResources.find((res) => res.id === jRet._lightID);
+          const linkedLight = allResources.find((res) => res.id === jScene.group.rid).children || [];
+          linkedLight.forEach((light) => {
+            this.writeHueQueueAdd(light.rid, jRet._state, "setLight");
+          });
+          break;
+        default:
+          break;
+      }
+    } catch (error) {
+      this.sysLogger?.error(`processQueueItem: ${error.message}`);
+    }
+  };
+
+  handleQueue = async () => {
+    do {
+      if (this.commandQueue && this.commandQueue.length > 0) {
+        try {
+          await this.processQueueItem();
+        } catch (error) { }
+      }
+      await pleaseWait(150);
+    } while (!this.exitAllQueues);
+  };
+
+  writeHueQueueAdd = async (_lightID, _state, _operation) => {
+    this.commandQueue.unshift({ _lightID, _state, _operation });
+  };
+
+  deleteHueQueue = async (_lightID) => {
+    this.commandQueue = this.commandQueue.filter((el) => el._lightID !== _lightID);
+  };
+
+  close = async () =>
+    new Promise((resolve, reject) => {
+      if (this.timerCheckConnected !== null) clearInterval(this.timerCheckConnected);
+      try {
+        this.exitAllQueues = true;
+        this.restartSSECounter = 0;
+        try {
+          if (this.eventStreamAbort) this.eventStreamAbort.abort();
+        } catch (error) { }
+        this.HUEBridgeConnectionStatus = "disconnected";
+        resolve(true);
+      } catch (error) {
+        reject(error);
+      }
+    });
+}
+
+export { classHUE };

package/package.json

@@ -3,22 +3,22 @@
   "engines": {
     "node": ">=18.0.0"
   },
-  "version": "3.3.29",
+  "version": "3.3.31",
   "description": "Control your KNX intallation via Node-Red! A bunch of KNX nodes, with integrated Philips HUE control and ETS group address importer. Easy to use and highly configurable.",
   "dependencies": {
     "binary-parser": "2.2.1",
     "crypto-js": "4.2.0",
     "dns-sync": "0.2.1",
-    "eventsource": "2.0.2",
     "js-yaml": "4.1.0",
     "knxultimate": "4.1.1",
     "lodash": "4.17.21",
-    "node-color-log": "12.0.1",
     "mkdirp": "3.0.1",
+    "node-color-log": "12.0.1",
     "node-hue-api": "5.0.0-beta.16",
     "path": "0.12.7",
     "ping": "0.4.4",
     "simple-get": "4.0.1",
+    "undici": "^7.8.0",
     "xml2js": "0.6.0"
   },
   "node-red": {

package/nodes/utils/hueEngine.js

@@ -1,256 +0,0 @@
-/* eslint-disable max-len */
-const { EventEmitter } = require("events");
-const EventSource = require("eventsource");
-const http = require("./http");
-const { setTimeout: pleaseWait } = require('timers/promises');
-//const { forEach } = require("lodash");
-// Configura il rate limiter
-//const limiter = new RateLimiter({ tokensPerInterval: 1, interval: 150 }); // HUE telegram interval
-
-class classHUE extends EventEmitter {
-
-  constructor(_hueBridgeIP, _username, _clientkey, _bridgeid, _sysLogger) {
-    super();
-    this.HUEBridgeConnectionStatus = "disconnected";
-    this.exitAllQueues = false;
-    this.hueBridgeIP = _hueBridgeIP;
-    this.username = _username;
-    this.clientkey = _clientkey;
-    this.bridgeid = _bridgeid;
-    this.commandQueue = [];
-    // eslint-disable-next-line max-len
-    this.sysLogger = _sysLogger;
-    this.timerCheckConnected = null;
-    this.restartSSECounter = 0; // To auto reset the SSE Connection
-    this.handleQueue();
-  }
-
-  Connect = () => {
-    if (this.timerCheckConnected !== null) clearInterval(this.timerCheckConnected);
-
-    const options = {
-      headers: {
-        "hue-application-key": this.username,
-        pragma: "no-cache",
-        "cache-control": "no-cache,no-store, must-revalidate",
-      },
-      https: {
-        rejectUnauthorized: false,
-      },
-    };
-
-    // Init the http to use the username and bridge ip
-    this.hueApiV2 = http.use({
-      key: this.username,
-      prefix: `https://${this.hueBridgeIP}/clip/v2`
-    });
-
-    try {
-      if (this.es !== null && this.es !== undefined) {
-        (async () => {
-          await this.close();
-          this.exitAllQueues = false;
-        })();
-      }
-    } catch (error) {
-      /* empty */
-    }
-
-    try {
-      this.es = new EventSource(`https://${this.hueBridgeIP}/eventstream/clip/v2`, options);
-    } catch (error) {
-      if (this.sysLogger !== undefined && this.sysLogger !== null) this.sysLogger.error(`hueEngine: ew EventSource: ${error.message}`);
-    }
-
-
-    this.es.onmessage = (event) => {
-      try {
-        if (event && event.type === "message" && event.data) {
-          const data = JSON.parse(event.data);
-          data.forEach((element) => {
-            if (element.type === "update") {
-              element.data.forEach((ev) => {
-                this.emit("event", ev);
-              });
-            }
-          });
-        }
-      } catch (error) {
-        if (this.sysLogger !== undefined && this.sysLogger !== null)
-          this.sysLogger.error(`KNXUltimatehueEngine: classHUE: this.es.onmessage: ${error.message}`);
-      }
-    };
-
-    this.es.onopen = () => {
-      // if (this.sysLogger !== undefined && this.sysLogger !== null) this.sysLogger.error('KNXUltimatehueEngine: classHUE: SSE-Connected')
-      this.emit("connected");
-      this.HUEBridgeConnectionStatus = "connected";
-      if (this.sysLogger !== undefined && this.sysLogger !== null) this.sysLogger.info(`KNXUltimatehueEngine: classHUE: this.es.onopen: connected`);
-      // Check wether the hue bridge is connected or not
-      if (this.timerCheckConnected !== null) clearInterval(this.timerCheckConnected);
-      this.timerCheckConnected = setInterval(() => {
-        (async () => {
-          try {
-            this.restartSSECounter += 1;
-            if (this.restartSSECounter >= 6) {
-              // Restart SSE client, due to silent disconnection affecting the SSE server
-              this.restartSSECounter = 0;
-              if (this.sysLogger !== undefined && this.sysLogger !== null) this.sysLogger.debug(`KNXUltimatehueEngine: classHUE:this.timerCheckConnected = setInterval: reconnection to the eventsource`);
-              this.es.close();
-              this.es = new EventSource(`https://${this.hueBridgeIP}/eventstream/clip/v2`, options);
-            }
-
-            if (this.sysLogger !== undefined && this.sysLogger !== null) this.sysLogger.debug(`KNXUltimatehueEngine: classHUE: Pinging...`);
-            const jReturn = await this.hueApiV2.get('/resource/bridge');
-            if (!Array.isArray(jReturn) || jReturn.length < 1) throw new Error("jReturn: not an array or array empty")
-            this.HUEBridgeConnectionStatus = "connected";
-            if (this.sysLogger !== undefined && this.sysLogger !== null) this.sysLogger.debug(`KNXUltimatehueEngine: classHUE: Ping OK`);
-
-          } catch (error) {
-            if (this.sysLogger !== undefined && this.sysLogger !== null) this.sysLogger.error(`KNXUltimatehueEngine: classHUE: Ping ERROR: ${error.message}`);
-            if (this.timerCheckConnected !== null) clearInterval(this.timerCheckConnected);
-            this.commandQueue = [];
-            try {
-              await this.close();
-            } catch (error) { }
-            this.restartSSECounter = 0;
-            this.emit("disconnected");
-          }
-        })();
-      }, 120000);
-    };
-
-    this.es.onerror = (error) => {
-      if (this.sysLogger !== undefined && this.sysLogger !== null) this.sysLogger.error(`KNXUltimatehueEngine: classHUE: this.es.onopen: ${error.message}`);
-      // (async () => {
-      //   await this.close();
-      //   if (this.HUEBridgeConnectionStatus === 'connected') this.emit('disconnected');
-      // })();
-
-      // 29/08/2023 NON riattivare, perchè alla disconnessione, va in loop e consuma tutto il pool di risorse.
-      //   try {
-      //     this.es.close();
-      //     this.es = null;
-      //     if (this.sysLogger !== undefined && this.sysLogger !== null) this.sysLogger.error(`KNXUltimatehueEngine: classHUE: request.on(error): ${error.message}`);
-      //   } catch (err) { /* empty */ }
-      //   this.Connect();
-      //   // this.emit('error', error)
-      // };
-    };
-  };
-
-  // Process single item in the queue
-  processQueueItem = async () => {
-    try {
-      const jRet = this.commandQueue.pop();
-      // jRet is ({ _lightID, _state, _operation });;
-      switch (jRet._operation) {
-        case "setLight":
-          // It can be a light or a grouped light
-          try {
-            const ok = await this.hueApiV2.put(`/resource/light/${jRet._lightID}`, jRet._state);
-          } catch (error) {
-            if (this.sysLogger !== undefined && this.sysLogger !== null) {
-              this.sysLogger.error(`KNXUltimatehueEngine: classHUE: processQueueItem: setLight light: ${error.message}.`);
-            }
-          }
-          break;
-        case "setGroupedLight":
-          try {
-            await this.hueApiV2.put(`/resource/grouped_light/${jRet._lightID}`, jRet._state);
-          } catch (error) {
-            if (this.sysLogger !== undefined && this.sysLogger !== null)
-              this.sysLogger.info(`KNXUltimatehueEngine: classHUE: processQueueItem: setLight grouped_light: ${error.message}`);
-          }
-          break;
-        case "setScene":
-          try {
-            const sceneID = jRet._lightID;
-            await this.hueApiV2.put(`/resource/scene/${sceneID}`, jRet._state);
-          } catch (error) {
-            if (this.sysLogger !== undefined && this.sysLogger !== null)
-              this.sysLogger.info(`KNXUltimatehueEngine: classHUE: processQueueItem: setScene: ${error.message}`);
-          }
-          break;
-        case "stopScene":
-          try {
-            const allResources = await this.hueApiV2.get("/resource");
-            const sceneID = jRet._lightID;
-            const jScene = allResources.find((res) => res.id === sceneID) || "";
-            const linkedLight = allResources.find((res) => res.id === jScene.group.rid).children || "";
-            linkedLight.forEach((light) => {
-              this.writeHueQueueAdd(light.rid, jRet._state, "setLight");
-            });
-          } catch (error) {
-            if (this.sysLogger !== undefined && this.sysLogger !== null) this.sysLogger.error(`KNXUltimatehueEngine: classHUE: processQueueItem: stopScene: ${error.message}`);
-          }
-          break;
-        default:
-          break;
-      }
-    } catch (error) {
-      if (this.sysLogger !== undefined && this.sysLogger !== null) this.sysLogger.error(`KNXUltimatehueEngine: classHUE: processQueueItem: ${error.trace}`);
-    }
-  };
-
-  // // Handle the send queue
-  // // ######################################
-  handleQueue = async () => {
-    // Verifica se è possibile eseguire una nuova richiesta
-    do {
-      if (this.commandQueue !== undefined && this.commandQueue.length > 0) {
-        //if (remainingRequests >= 0) {
-        // OK, i can send
-        //console.log("\x1b[32m Messaggio. remainingRequests=" + remainingRequests + "\x1b[0m " + new Date().toTimeString(), this.commandQueue.length, "remainingRequests " + remainingRequests);
-        try {
-          await this.processQueueItem();
-        } catch (error) {
-        }
-        //} else {
-        // Limit reached, skip this round.
-        //console.log("\x1b[41m HO DETTO SPETA. remainingRequests=" + remainingRequests + "\x1b[0m " + new Date().toTimeString(), this.commandQueue.length, "remainingRequests " + remainingRequests);
-        //}
-      }
-      await pleaseWait(150);
-    } while (!this.exitAllQueues);
-    //console.log("\x1b[42m End processing commandQueue \x1b[0m " + new Date().toTimeString(), this.commandQueue.length);
-  };
-
-
-  writeHueQueueAdd = async (_lightID, _state, _operation) => {
-    // Add the new item
-    this.commandQueue.unshift({ _lightID, _state, _operation });
-  };
-
-  /**
-  * Clears all items fo _lightID from the HUE sending queue. Useful to clear unwanted dimming commands
-  * @param {string} _lightID HUE Light ID
-  * @returns {}
-  */
-  deleteHueQueue = async (_lightID) => {
-    // Add the new item
-    this.commandQueue = this.commandQueue.filter((el) => el._lightID !== _lightID);
-  };
-  // ######################################
-
-  close = async () =>
-    new Promise((resolve, reject) => {
-      if (this.timerCheckConnected !== null) clearInterval(this.timerCheckConnected);
-      try {
-        this.exitAllQueues = true;
-        this.restartSSECounter = 0;
-        setTimeout(() => {
-          try {
-            if (this.es !== null && this.es !== undefined) this.es.close();
-            if (this.es !== null && this.es !== undefined) this.es.removeEventListener();
-          } catch (error) { }
-          this.es = null;
-          this.HUEBridgeConnectionStatus = "disconnected";
-          resolve(true);
-        }, 2000);
-      } catch (error) {
-        reject(error);
-      }
-    });
-}
-module.exports.classHUE = classHUE;