@evops/lightwaverf 0.0.4 → 0.0.8

package/LICENSE

@@ -0,0 +1,7 @@
+Copyright 2022 Evops Limited
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -1,83 +1,3 @@
-node-lightwaverf
-================
-
-A NodeJS library for controlling devices using the LightwaveRF Wi-Fi Link
-
-## Installation
-
-    npm install lightwaverf
-
-## Usage
-
-### Initialize
-
-    var LightwaveRF = require("lightwaverf");
-    var lw = new LightwaveRF({ip:"192.168.1.123",email:"name@host.com",pin:"0123"});
-
-Or to read from a [LightwareRF Gem](https://github.com/pauly/lightwaverf) format YAML file:
-
-    var lw = new LightwaveRF({ip:"192.168.1.123", file:"/a/config/file.yml"});
-
-### Turn a device on
-
-To turn a device on you need to have set it up using the mobile or web app. You need the room ID and the device ID.
-
-    lw.turnDeviceOn(1 /*roomId*/, 1 /*deviceId*/, function(error, content) {
-        if (error) {
-            console.log("Error turning device on " + error.message);
-        } else {
-            console.log("Response: " + content);
-        }
-    });
-
-### Turn a device off
-
-To turn a device off you need to have set it up using the mobile or web app. You need the room ID and the device ID.
-
-    lw.turnDeviceOff(1 /*roomId*/, 1 /*deviceId*/, function(error, content) {
-        if (error) {
-            console.log("Error turning device off " + error.message);
-        } else {
-            console.log("Response: " + content);
-        }
-    });
-
-### Dim the device in a room
-
-To turn a dim the device in a room you need to have set it up using the mobile or web app. You need the room ID and device ID.
-
-    lw.setDeviceDim(1 /*roomId*/, 1 /*deviceId*/, 50 /*percentage from 0-100*/, function(error, content) {
-        if (error) {
-            console.log("Error changing dim of device " + error.message);
-        } else {
-            console.log("Response: " + content);
-        }
-    });
-
-### Turn a room off
-
-To turn a room off you need to have set it up using the mobile or web app. You need the room ID.
-
-    lw.turnRoomOff(1 /*roomId*/, function(error, content) {
-        if (error) {
-            console.log("Error turning room off " + error.message);
-        } else {
-            console.log("Response: " + content);
-        }
-    });
-
-### Request the energy status
-
-To get the current status from the LightwaveRF Energy Monitor Smart Meter you need to have linked it to the Wi-Fi Link first.
-
-    lw.requestEnergy(function(error, data) {
-        if (error) {
-            console.log("Error turning device off " + error.message);
-        } else {
-            //data: { current: 300, max: 620, today: 850, yesterday: 0 }
-            console.log("Energy ", data);
-        }
-    });
-
-
+# LightwaveRF client library
 
+Originally based on https://github.com/ollieparsley/node-lightwaverf

package/dist/LightwaveAccount.d.ts

@@ -0,0 +1,13 @@
+import Debug, { Debugger } from "debug";
+import { LightwaveDevice } from "./LightwaveDevice";
+import { LightwaveRFClient } from "./LightwaveRFClient";
+export declare class LightwaveAccount {
+    debug: Debug.Debugger;
+    client: LightwaveRFClient;
+    email: string;
+    pin: string;
+    mainDebug: Debug.Debugger;
+    constructor(debug: Debugger, client: LightwaveRFClient, email: string, pin: string);
+    getConfiguration(callback: any): void;
+    parseRooms(lightwaveResponse: any, callback: (devices: LightwaveDevice[], error: Error | null) => void): void;
+}

package/dist/LightwaveAccount.js

@@ -0,0 +1,81 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LightwaveAccount = void 0;
+const request_promise_1 = __importDefault(require("request-promise"));
+const LightwaveDevice_1 = require("./LightwaveDevice");
+class LightwaveAccount {
+    constructor(debug, client, email, pin) {
+        if (!email || !pin) {
+            throw "No email or pin specified. The server configuration (rooms, devices, etc.) cannot be obtained";
+        }
+        this.mainDebug = debug;
+        this.debug = debug.extend('account');
+        this.client = client;
+        this.email = email;
+        this.pin = pin;
+    }
+    getConfiguration(callback) {
+        this.debug('Getting rooms from LightWave');
+        var self = this;
+        var host = 'https://control-api.lightwaverf.com';
+        var json = request_promise_1.default.defaults({
+            json: true
+        });
+        var auth, token;
+        json.get(host + '/v1/user?password=' + this.pin + '&username=' + this.email)
+            .then(function (res) {
+            return json.get(host + '/v1/auth?application_key=' + res.application_key);
+        })
+            .then(function (res) {
+            token = res.token;
+            auth = json.defaults({
+                headers: {
+                    'X-LWRF-token': token,
+                    'X-LWRF-platform': 'ios',
+                    'X-LWRF-skin': 'lightwaverf'
+                }
+            });
+            return auth.get(host + '/v1/device_type?nested=1');
+        })
+            .then(function (res) {
+            return auth.get(host + '/v1/user_profile?nested=1');
+        })
+            .then(function (res) {
+            self.parseRooms(res, callback);
+        });
+    }
+    parseRooms(lightwaveResponse, callback) {
+        this.debug('Parsing lightwaveResponse: ', lightwaveResponse.content.estates[0].locations[0].zones[0].rooms[0].devices);
+        const home = lightwaveResponse.content.estates[0].locations[0].zones[0];
+        const devices = [];
+        for (var i = 0; i < home.rooms.length; i++) {
+            var r = home.rooms[i];
+            this.debug("Room " + r.name + " with " + r.devices.length + " devices");
+            // Get device types
+            //   O: On/Off Switch
+            //   D: Dimmer
+            //   R: Radiator(s)
+            //   P: Open/Close
+            //   I: Inactive (i.e. not configured)
+            //   m: Mood (inactive)
+            //   M: Mood (active)
+            //   o: All Off
+            var deviceTypeMapping = new Map();
+            deviceTypeMapping.set(1, LightwaveDevice_1.LightwaveDeviceType.OnOff);
+            deviceTypeMapping.set(2, LightwaveDevice_1.LightwaveDeviceType.Dimmer);
+            deviceTypeMapping.set(3, LightwaveDevice_1.LightwaveDeviceType.OnOff);
+            for (var j = 0; j < r.devices.length; j++) {
+                var d = r.devices[j];
+                const device = new LightwaveDevice_1.LightwaveDevice(this.client, this.mainDebug, r.room_number, d.device_number, r.name, d.name, deviceTypeMapping.get(d.device_type_id));
+                devices.push(device);
+            }
+        }
+        this.debug('Devices: %O', devices);
+        callback(devices, null);
+    }
+    ;
+}
+exports.LightwaveAccount = LightwaveAccount;

package/dist/LightwaveDevice.d.ts

@@ -0,0 +1,26 @@
+import Debug from 'debug';
+import { LightwaveRFClient } from './LightwaveRFClient';
+export interface LightwaveRFDeviceInterface {
+    roomId: number;
+    deviceId: number;
+    roomName: string;
+    deviceName: string;
+    deviceType: string;
+}
+export declare enum LightwaveDeviceType {
+    Dimmer = "D",
+    OnOff = "O"
+}
+export declare class LightwaveDevice implements LightwaveRFDeviceInterface {
+    roomId: number;
+    deviceId: number;
+    roomName: string;
+    deviceName: string;
+    deviceType: LightwaveDeviceType;
+    client: LightwaveRFClient;
+    debug: Debug.Debugger;
+    constructor(client: LightwaveRFClient, debug: debug.Debugger, roomId: number, deviceId: number, roomName: string, deviceName: string, deviceType: LightwaveDeviceType);
+    turnOn(): Promise<void>;
+    turnOff(): Promise<void>;
+    dim(percentage: number): Promise<void>;
+}

package/dist/LightwaveDevice.js

@@ -0,0 +1,64 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LightwaveDevice = exports.LightwaveDeviceType = void 0;
+var LightwaveDeviceType;
+(function (LightwaveDeviceType) {
+    LightwaveDeviceType["Dimmer"] = "D";
+    LightwaveDeviceType["OnOff"] = "O";
+})(LightwaveDeviceType = exports.LightwaveDeviceType || (exports.LightwaveDeviceType = {}));
+class LightwaveDevice {
+    constructor(client, debug, roomId, deviceId, roomName, deviceName, deviceType) {
+        this.client = client;
+        this.debug = debug.extend(deviceName);
+        this.roomId = roomId;
+        this.deviceId = deviceId;
+        this.roomName = roomName;
+        this.deviceName = deviceName;
+        this.deviceType = deviceType;
+    }
+    turnOn() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                this.debug("Device turning on");
+                this.client.send(`R${this.roomId}D${this.deviceId}F1`, (message, error) => {
+                    resolve();
+                });
+            });
+        });
+    }
+    turnOff() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                this.debug("Device turning off");
+                this.client.send(`R${this.roomId}D${this.deviceId}F0`, (message, error) => {
+                    if (error)
+                        return reject(error);
+                    resolve();
+                });
+            });
+        });
+    }
+    dim(percentage) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve, reject) => {
+                this.debug("Device dimming to %d", percentage);
+                const lwDim = Math.round(percentage * 0.32);
+                this.client.send(`R${this.roomId}D${this.deviceId}FdP${lwDim}`, (message, error) => {
+                    if (error)
+                        return reject(error);
+                    resolve();
+                });
+            });
+        });
+    }
+}
+exports.LightwaveDevice = LightwaveDevice;

package/dist/LightwaveJsonMessageProcessor.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="node" />
+import { Debugger } from "debug";
+import "./LightwaveTransaction";
+import LightwaveMessageProcessor from "./LightwaveMessageProcessor";
+export declare class LightwaveJsonMessageProcessor implements LightwaveMessageProcessor {
+    debug: Debugger;
+    constructor(debug: Debugger);
+    process(message: Buffer): any;
+    canProcess(message: Buffer): boolean;
+}

package/dist/LightwaveJsonMessageProcessor.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LightwaveJsonMessageProcessor = void 0;
+require("./LightwaveTransaction");
+class LightwaveJsonMessageProcessor {
+    constructor(debug) {
+        this.debug = debug.extend('jsonMessageProcessor');
+    }
+    process(message) {
+        var _a;
+        this.debug('Processing message');
+        const textMessage = message.toString('utf-8').replace('*!', '');
+        const json = JSON.parse(textMessage);
+        const response = json;
+        response.id = json.trans;
+        response.error = (_a = json.error) !== null && _a !== void 0 ? _a : null;
+        return response;
+    }
+    canProcess(message) {
+        this.debug("Checking if can process message");
+        return message.toString('utf-8').startsWith('*!');
+    }
+}
+exports.LightwaveJsonMessageProcessor = LightwaveJsonMessageProcessor;

package/dist/LightwaveMessage.d.ts

@@ -0,0 +1,9 @@
+import debug from 'debug';
+export declare interface LightwaveTransaction {
+    id: number;
+    message: string;
+    error: any;
+    debug: debug.Debugger;
+    delay: number;
+    callback: (message: LightwaveTransaction, error: Error) => void;
+}

package/dist/LightwaveMessage.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/LightwaveMessageProcessor.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="node" />
+import "./LightwaveTransaction";
+declare interface LightwaveMessageProcessor {
+    process(message: Buffer): any;
+    canProcess(message: Buffer): boolean;
+}
+export default LightwaveMessageProcessor;

package/dist/LightwaveMessageProcessor.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("./LightwaveTransaction");

package/dist/LightwaveRFClient.d.ts

@@ -0,0 +1,32 @@
+/// <reference types="node" />
+import events from 'events';
+import { Debugger } from 'debug';
+import { LightwaveTransaction } from './LightwaveTransaction';
+declare interface LightwaveRFClientInterface {
+    on(event: 'ready', listener: (client: LightwaveRFClient) => void): this;
+    on(event: 'deviceTurnedOn', listener: (room: number, device: number) => void): this;
+    on(event: 'deviceTurnedOff', listener: (room: number, device: number) => void): this;
+    on(event: 'deviceDimmed', listener: (room: number, device: number, dimPercentage: number) => void): this;
+}
+export declare class LightwaveRFClient extends events.EventEmitter implements LightwaveRFClientInterface {
+    private senderSocket;
+    private receiverSocket;
+    private senderSocketReady;
+    private receiverSocketReady;
+    private commandQueue;
+    private messageProcessors;
+    private debug;
+    private ip;
+    private transactionListeners;
+    delay: number;
+    constructor(debug: Debugger, ip?: string, port?: number);
+    stop(): void;
+    private socketReady;
+    private checkRegistration;
+    send(message: (string | Buffer), callback: (transaction: LightwaveTransaction | null, error: Error) => void): void;
+    private processQueue;
+    private exec;
+    private processRawMessage;
+    processLightwaveMessage(lightwaveMessage: any): void;
+}
+export {};

package/dist/LightwaveRFClient.js

@@ -0,0 +1,202 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LightwaveRFClient = void 0;
+const dgram_1 = __importDefault(require("dgram"));
+const events_1 = __importDefault(require("events"));
+const LightwaveTextMessageProcessor_1 = __importDefault(require("./LightwaveTextMessageProcessor"));
+const LightwaveJsonMessageProcessor_1 = require("./LightwaveJsonMessageProcessor");
+const Queue_1 = require("./Queue");
+class LightwaveRFClient extends events_1.default.EventEmitter {
+    constructor(debug, ip = "255.255.255.255", port = 9761) {
+        super();
+        this.senderSocketReady = false;
+        this.receiverSocketReady = false;
+        this.commandQueue = new Queue_1.Queue();
+        this.messageProcessors = [];
+        this.transactionListeners = new Map();
+        this.delay = 125;
+        this.ip = ip;
+        this.debug = debug.extend('client');
+        this.senderSocket = dgram_1.default.createSocket('udp4');
+        this.receiverSocket = dgram_1.default.createSocket('udp4');
+        this.messageProcessors.push(new LightwaveJsonMessageProcessor_1.LightwaveJsonMessageProcessor(this.debug));
+        this.messageProcessors.push(new LightwaveTextMessageProcessor_1.default(this.debug));
+        this.receiverSocket.on('message', (buffer) => {
+            this.debug("RAW: %o", buffer.toString('utf-8'));
+        });
+        this.receiverSocket.on('message', this.processRawMessage.bind(this));
+        this.receiverSocket.once('listening', () => {
+            this.debug("Receiver socket bound", this.receiverSocket.address());
+            this.receiverSocketReady = true;
+        });
+        this.receiverSocket.once('listening', this.socketReady.bind(this));
+        this.senderSocket.once('listening', () => {
+            this.debug("Sender socket bound", this.senderSocket.address());
+            this.senderSocketReady = true;
+        });
+        this.senderSocket.once('listening', this.socketReady.bind(this));
+        this.senderSocket.unref();
+        this.senderSocket.bind();
+        this.debug("Binding receiver socket on address %s and port %d", ip, port);
+        this.receiverSocket.bind(port);
+        this.receiverSocket.on('error', () => {
+            throw new Error("Error binding receiver socket");
+        });
+        process.on('SIGINT', () => {
+            this.debug("\nClosing sockets");
+            this.stop();
+            process.exit();
+        });
+    }
+    stop() {
+        try {
+            this.receiverSocket.close();
+        }
+        catch (_a) { }
+    }
+    socketReady() {
+        if (!this.senderSocketReady)
+            return;
+        if (!this.receiverSocketReady)
+            return;
+        this.checkRegistration();
+        this.processQueue();
+    }
+    checkRegistration() {
+        this.debug("Checking registration");
+        this.send("@H", (transaction, error) => {
+            if (error) {
+                this.debug('Error: %o', error);
+            }
+            this.debug(transaction);
+            this.emit('ready');
+        });
+    }
+    send(message, callback) {
+        const transaction = Math.round(Math.random() * Math.pow(10, 8));
+        const messageWithTransaction = `${transaction},!${message}`;
+        const transactionDebug = this.debug.extend("transaction:" + transaction);
+        this.transactionListeners.set(transaction, {
+            message: message,
+            debug: transactionDebug,
+            delay: this.delay,
+            callback: callback
+        });
+        this.debug("Queueing message: %s", messageWithTransaction);
+        this.commandQueue.add({
+            id: transaction,
+            message: messageWithTransaction,
+            debug: transactionDebug,
+            callback
+        });
+        this.processQueue();
+    }
+    processQueue() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.commandQueue.busy) {
+                setTimeout(this.processQueue.bind(this), this.delay);
+                return;
+            }
+            ;
+            const command = this.commandQueue.receive();
+            if (!command)
+                return;
+            this.commandQueue.busy = true;
+            const transactionListener = this.transactionListeners.get(command.id);
+            const originalCallback = transactionListener.callback;
+            transactionListener.callback = (transaction, error) => {
+                this.commandQueue.busy = false;
+                setTimeout(this.processQueue.bind(this), this.delay);
+                originalCallback(transaction, error);
+            };
+            setTimeout(() => {
+                const listener = this.transactionListeners.get(command.id);
+                if (!listener)
+                    return;
+                originalCallback(null, new Error("Execution expired"));
+                this.transactionListeners.delete(command.id);
+                this.processQueue();
+            }, 5000);
+            const transactionDebug = this.debug.extend(`transaction:${command === null || command === void 0 ? void 0 : command.id}`);
+            transactionDebug("Starting new transaction");
+            this.exec(command.message, (message, error) => { });
+        });
+    }
+    exec(message, callback) {
+        if (message === undefined)
+            return;
+        this.debug("Sending message: %s to %s on port %d", message, this.ip, 9760);
+        this.senderSocket.setBroadcast(this.ip === "255.255.255.255");
+        this.senderSocket.send(message, 9760, this.ip, (error, bytes) => {
+            if (error) {
+                this.debug("Message send errror: %o", error);
+            }
+            this.debug("Message sent: %s, length: %d", message, bytes);
+        });
+    }
+    processRawMessage(message, remoteInfo) {
+        this.debug("Message has come through from %o", remoteInfo);
+        this.debug("Message received: %o", message.toString('ascii'));
+        for (const messageProcessor of this.messageProcessors) {
+            if (messageProcessor.canProcess(message)) {
+                this.debug("Message can be processed by %s", messageProcessor.constructor.name);
+                const lightwaveMessage = messageProcessor.process(message);
+                this.processLightwaveMessage(lightwaveMessage);
+                return;
+            }
+        }
+        throw "Message cannot be processed";
+    }
+    processLightwaveMessage(lightwaveMessage) {
+        var _a;
+        this.debug("Processing lightwave message: %o", lightwaveMessage);
+        this.debug("Current listeners: %o", this.transactionListeners);
+        this.debug("Link response fn", lightwaveMessage.fn);
+        if (lightwaveMessage.fn === "on") {
+            this.emit("deviceTurnedOn", lightwaveMessage.room, lightwaveMessage.dev);
+        }
+        if (lightwaveMessage.fn === "off") {
+            this.emit("deviceTurnedOff", lightwaveMessage.room, lightwaveMessage.dev);
+        }
+        if (lightwaveMessage.fn === "dim") {
+            this.emit("deviceDimmed", lightwaveMessage.room, lightwaveMessage.dev, Math.round(lightwaveMessage.param / 32 * 100));
+        }
+        const listener = this.transactionListeners.get(lightwaveMessage.id);
+        if (!listener)
+            return;
+        if ((_a = lightwaveMessage.error) === null || _a === void 0 ? void 0 : _a.match(/^ERR,6,/)) {
+            listener.delay = listener.delay * 2;
+            const msg = `${lightwaveMessage.id},!${listener.message}`;
+            this.debug("message errorred, retrying: %o, %o with delay: %o", msg, listener, listener.delay);
+            setTimeout(() => {
+                this.exec(msg, (message, error) => {
+                    this.debug("message: %o, error: %o", message, error);
+                });
+            }, Math.round(listener.delay));
+            return;
+        }
+        if (listener) {
+            listener.debug("Found transaction listener");
+            listener.callback(lightwaveMessage, null);
+            listener.debug("Transaction completed, removing listener");
+            this.transactionListeners.delete(lightwaveMessage.id);
+            this.commandQueue.busy = false;
+        }
+        else {
+            this.debug("Listener not found for message: %o", lightwaveMessage);
+        }
+    }
+}
+exports.LightwaveRFClient = LightwaveRFClient;

package/dist/LightwaveTextMessageProcessor.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="node" />
+import { Debugger } from "debug";
+import "./LightwaveTransaction";
+import LightwaveMessageProcessor from "./LightwaveMessageProcessor";
+export default class LightwaveTextMessageProcessor implements LightwaveMessageProcessor {
+    debug: Debugger;
+    constructor(debug: Debugger);
+    process(message: Buffer): any;
+    canProcess(message: Buffer): boolean;
+}

package/dist/LightwaveTextMessageProcessor.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("./LightwaveTransaction");
+class LightwaveTextMessageProcessor {
+    constructor(debug) {
+        this.debug = debug.extend('textMessageProcessor');
+    }
+    process(message) {
+        this.debug('Processing message');
+        const textMessage = message.toString('utf-8');
+        var parts = textMessage.split(",");
+        var trans = parts.splice(0, 1);
+        var content = parts.join(",").replace(/(\r\n|\n|\r)/gm, "");
+        const response = {};
+        response.id = parseInt(trans[0]);
+        response.message = content;
+        response.error = content.match("^ERR") ? content : null;
+        return response;
+    }
+    canProcess(message) {
+        this.debug("Checking if can process message");
+        return message.toString('utf-8').endsWith("\n");
+    }
+}
+exports.default = LightwaveTextMessageProcessor;

package/dist/LightwaveTransaction.d.ts

@@ -0,0 +1,8 @@
+import debug from 'debug';
+export declare interface LightwaveTransaction {
+    id: number;
+    message: string;
+    error: any;
+    debug: debug.Debugger;
+    callback: (message: LightwaveTransaction, error: Error) => void;
+}

package/dist/LightwaveTransaction.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/Queue.d.ts

@@ -0,0 +1,7 @@
+export declare class Queue<T> {
+    items: T[];
+    busy: boolean;
+    get length(): number;
+    add(item: T): void;
+    receive(): T | undefined;
+}

package/dist/Queue.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Queue = void 0;
+class Queue {
+    constructor() {
+        this.items = [];
+        this.busy = false;
+    }
+    get length() {
+        return this.items.length;
+    }
+    add(item) {
+        this.items.push(item);
+    }
+    receive() {
+        return this.items.shift();
+    }
+}
+exports.Queue = Queue;