@evops/lightwaverf 1.0.3 → 1.0.4

package/.dist/LightwaveRFClient.d.ts

@@ -22,7 +22,10 @@ export declare class LightwaveRFClient extends events.EventEmitter implements Li
     model?: string;
     uptime?: number;
     version?: string;
-    constructor(debug: Debugger, ip?: string);
+    discoverLinkIp: boolean;
+    constructor(debug: Debugger, ip?: string, { discoverLinkIp }?: {
+        discoverLinkIp?: boolean;
+    });
     connect(): Promise<void>;
     disconnect(): Promise<[void, void]>;
     private checkRegistration;

package/.dist/LightwaveRFClient.js

@@ -19,15 +19,17 @@ class LightwaveRFClient extends events_1.default.EventEmitter {
     messageProcessors = [];
     debug;
     transactionListeners = new Map();
-    delay = 125;
+    delay = 800;
     serial;
     mac;
     model;
     uptime;
     version;
-    constructor(debug, ip = "255.255.255.255") {
+    discoverLinkIp;
+    constructor(debug, ip = "255.255.255.255", { discoverLinkIp = true } = {}) {
         super();
         this.ip = ip;
+        this.discoverLinkIp = discoverLinkIp;
         this.debug = debug.extend("client");
         this.senderSocket = dgram_1.default.createSocket("udp4");
         this.senderSocket.unref();
@@ -78,18 +80,18 @@ class LightwaveRFClient extends events_1.default.EventEmitter {
         });
     }
     send(message, callback) {
-        const transaction = Math.round(Math.random() * Math.pow(10, 8));
-        const messageWithTransaction = `${transaction},${message}`;
-        const transactionDebug = this.debug.extend("tx:" + transaction);
-        this.transactionListeners.set(transaction, {
+        const transactionId = Math.round(Math.random() * Math.pow(10, 8));
+        const messageWithTransaction = `${transactionId},${message}`;
+        const transactionDebug = this.debug.extend("tx:" + transactionId);
+        this.transactionListeners.set(transactionId, {
             message: message,
             debug: transactionDebug,
             delay: this.delay,
             callback: callback,
         });
-        this.debug("Queueing message: %s", messageWithTransaction);
+        this.debug("[%d] Queueing message: %s", Date.now(), messageWithTransaction);
         this.commandQueue.add({
-            id: transaction,
+            id: transactionId,
             message: messageWithTransaction,
             debug: transactionDebug,
             callback,
@@ -98,26 +100,31 @@ class LightwaveRFClient extends events_1.default.EventEmitter {
     }
     async processSendQueue() {
         if (this.commandQueue.busy) {
-            setTimeout(this.processSendQueue.bind(this), this.delay);
+            this.debug(`The queue is busy, will wait to process`);
             return;
         }
         const command = this.commandQueue.next();
         if (!command)
             return;
+        this.debug(`Processing command: %o`, { command });
         this.commandQueue.busy = true;
         const transactionListener = this.transactionListeners.get(command.id);
         const originalCallback = transactionListener.callback;
         transactionListener.callback = (transaction, error) => {
-            this.commandQueue.busy = false;
             originalCallback?.(transaction, error);
-            setTimeout(this.processSendQueue.bind(this), this.delay);
+            this.debug("Transaction %d completed, scheduling next processing in %dms !!!!!!!!!!", transaction.id, this.delay);
+            setTimeout(() => {
+                this.commandQueue.busy = false;
+                this.processSendQueue();
+            }, this.delay);
         };
         // If we didn't hear back within the timeout
         setTimeout(() => {
             const listener = this.transactionListeners.get(command.id);
             if (!listener)
                 return;
-            originalCallback?.(null, new Error("Execution expired"));
+            originalCallback?.(null, new Error("Execution expired " + command.id));
+            this.commandQueue.busy = false;
             this.transactionListeners.delete(command.id);
             this.processSendQueue();
         }, 5000);
@@ -144,15 +151,14 @@ class LightwaveRFClient extends events_1.default.EventEmitter {
             if (messageProcessor.canProcess(message)) {
                 this.debug("Message can be processed by %s", messageProcessor.constructor.name);
                 const lightwaveMessage = messageProcessor.process(message);
-                this.processLightwaveMessage(lightwaveMessage);
+                this.processLightwaveMessage(lightwaveMessage, remoteInfo);
                 return;
             }
         }
         throw "Message cannot be processed";
     }
-    processLightwaveMessage(lightwaveMessage) {
+    processLightwaveMessage(lightwaveMessage, remoteInfo) {
         this.debug("Processing lightwave message: %o", lightwaveMessage);
-        this.debug("Current listeners: %o", this.transactionListeners);
         this.debug("Link response fn", lightwaveMessage.fn);
         // update info from link
         if (lightwaveMessage.serial) {
@@ -167,8 +173,8 @@ class LightwaveRFClient extends events_1.default.EventEmitter {
         if (lightwaveMessage.uptime) {
             this.uptime = lightwaveMessage.uptime;
         }
-        if (lightwaveMessage.ip) {
-            this.ip = lightwaveMessage.ip;
+        if (this.discoverLinkIp) {
+            this.ip = remoteInfo.address;
         }
         if (lightwaveMessage.fw) {
             this.version ??= lightwaveMessage.fw;
@@ -194,20 +200,21 @@ class LightwaveRFClient extends events_1.default.EventEmitter {
         if (!listener)
             return;
         if (lightwaveMessage.error?.match(/^ERR,6,/)) {
-            listener.delay = listener.delay * 2;
-            const msg = `${lightwaveMessage.id},!${listener.message}`;
+            // Storing delay on a message level provides the ability to implement
+            // exponential backoff, here the maximum is 10 seconds
+            listener.delay = Math.min(listener.delay * 2, 10000);
+            const msg = `${lightwaveMessage.id},${listener.message}`;
             this.debug("message errorred, retrying: %o, %o with delay: %o", msg, listener, listener.delay);
             setTimeout(() => {
                 this.exec(msg);
-            }, Math.round(listener.delay));
+            }, Math.round(listener.delay * 2));
             return;
         }
-        this.commandQueue.busy = false;
         if (listener) {
             listener.debug("Found transaction listener");
-            listener.callback(lightwaveMessage, null);
-            listener.debug("Transaction completed, removing listener");
+            listener.debug("[%d] Transaction completed, removing listener", Date.now());
             this.transactionListeners.delete(lightwaveMessage.id);
+            listener.callback(lightwaveMessage, null);
         }
         else {
             this.debug("Listener not found for message: %o", lightwaveMessage);

package/.dist/index.d.ts

@@ -12,6 +12,7 @@ declare class LightwaveRFConfiguration {
     host?: any;
     email?: any;
     pin?: any;
+    linkDisplayUpdates?: boolean;
 }
 declare interface ILightwaveRF {
     on(event: "deviceTurnedOn", listener: (roomId: number, deviceId: number) => void): this;
@@ -42,7 +43,8 @@ export default class LightwaveRF extends EventEmitter<LightwaveEvents> implement
     lwClient: LightwaveRFClient;
     lwAccount: LightwaveAccount;
     debug: debug.Debugger;
-    constructor({ email, pin, ip, timeout }: LightwaveRFConfiguration);
+    private linkDisplayUpdates;
+    constructor({ email, pin, ip, timeout, linkDisplayUpdates, }: LightwaveRFConfiguration);
     get serial(): string | undefined;
     get mac(): string | undefined;
     get uptime(): number | undefined;

package/.dist/index.js

@@ -17,6 +17,7 @@ class LightwaveRFConfiguration {
     host;
     email;
     pin;
+    linkDisplayUpdates;
 }
 /** * LightwaveRF API
  *
@@ -37,10 +38,12 @@ class LightwaveRF extends events_1.EventEmitter {
     lwClient;
     lwAccount;
     debug;
-    constructor({ email, pin, ip, timeout }) {
+    linkDisplayUpdates;
+    constructor({ email, pin, ip, timeout, linkDisplayUpdates = true, }) {
         super();
         this.setMaxListeners(255);
         this.debug = (0, debug_1.default)("lightwave");
+        this.linkDisplayUpdates = linkDisplayUpdates;
         this.debug("Initialising LightwaveRF Client");
         this.lwClient = new LightwaveRFClient_1.LightwaveRFClient(this.debug, ip);
         this.lwClient.once("ready", () => {
@@ -83,14 +86,41 @@ class LightwaveRF extends events_1.EventEmitter {
         }));
     }
     async turnOn({ roomId, deviceId, roomName, deviceName }) {
-        this.lwClient.send(`!F1R${roomId}D${deviceId}|${roomName} ${deviceName}|Turn on|`);
+        const { promise, resolve, reject } = Promise.withResolvers();
+        const linkDisplayUpdate = this.linkDisplayUpdates
+            ? `|${roomName} ${deviceName}|Turn on|`
+            : "";
+        this.lwClient.send(`!F1R${roomId}D${deviceId}${linkDisplayUpdate}`, (_, error) => {
+            if (error)
+                return reject(error);
+            resolve();
+        });
+        return promise;
     }
     async turnOff({ roomId, deviceId, roomName, deviceName }) {
-        this.lwClient.send(`!F0R${roomId}D${deviceId}|${roomName} ${deviceName}|Turn off|`);
+        const { promise, resolve, reject } = Promise.withResolvers();
+        const linkDisplayUpdate = this.linkDisplayUpdates
+            ? `|${roomName} ${deviceName}|Turn off|`
+            : "";
+        this.lwClient.send(`!F0R${roomId}D${deviceId}${linkDisplayUpdate}`, (_, error) => {
+            if (error)
+                return reject(error);
+            resolve();
+        });
+        return promise;
     }
     async dim({ roomId, deviceId, roomName, deviceName }, percentage) {
+        const { promise, resolve, reject } = Promise.withResolvers();
         const lwDim = Math.round(percentage * 0.32);
-        this.lwClient.send(`!FdP${lwDim}R${roomId}D${deviceId}|${roomName} ${deviceName}|Dim to ${percentage}%|`);
+        const linkDisplayUpdate = this.linkDisplayUpdates
+            ? `|${roomName} ${deviceName}|Dim to ${percentage}%|`
+            : "";
+        this.lwClient.send(`!FdP${lwDim}R${roomId}D${deviceId}${linkDisplayUpdate}`, (_, error) => {
+            if (error)
+                return reject(error);
+            resolve();
+        });
+        return promise;
     }
     async connect() {
         return this.lwClient.connect();

package/.dist/index.test.js

@@ -22,22 +22,31 @@ const _1 = __importDefault(require("."));
         // const devices = await lw.getDevices();
         await lw.connect();
         await lw.ensureRegistration();
+        await lw.lwClient.disconnect();
     });
     (0, vitest_1.it)("should turn device on", async () => {
         const lw = new _1.default({
             email: "some@user.com",
             pin: "1234",
+            // Disabling link display updates as they cause buffer issues in the link
+            // device
+            linkDisplayUpdates: true,
         });
         // const devices = await lw.getDevices();
         await lw.connect();
         // await lw.ensureRegistration();
         const devices = await lw.getDevices();
         const wallLamps = devices?.find((d) => {
-            return d.deviceName === "Wall lamps";
+            return d.deviceName === "Table lamp";
         });
         if (!wallLamps) {
-            throw new Error("Could not find wall lamps in the config");
+            throw new Error("Could not find table lamp in the config");
         }
-        lw.turnOff(wallLamps);
-    });
+        for (let i = 0; i < 5; i++) {
+            console.debug("Turning device on and off", i);
+            await lw.turnOn(wallLamps);
+            await lw.turnOff(wallLamps);
+        }
+        await lw.lwClient.disconnect();
+    }, 30000);
 });

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@evops/lightwaverf",
   "description": "Lightwave RF client library",
-  "version": "1.0.3",
+  "version": "1.0.4",
   "exports": {
     ".": {
       "types": "./.dist/index.d.ts",