@blueyerobotics/blueye-ts 2.0.0 → 3.0.0

package/README.md

@@ -15,19 +15,23 @@ import { BlueyeClient } from "@blueyerobotics/blueye-ts";
 
 const client = new BlueyeClient();
 
-// request battery information
-const batteryRep = await client.sendRequest("GetBatteryReq");
-console.log("batteryRep:", batteryRep);
+client.on("connected", async () => {
+  // request battery information
+  const batteryRep = await client.sendRequest("GetBatteryReq");
+  console.log("batteryRep:", batteryRep);
 
-// get latest battery telemetry
-const batteryTel = await client.getTelemetry("BatteryTel");
-console.log("batteryTel:", batteryTel);
+  // get latest battery telemetry
+  const batteryTel = await client.getTelemetry("BatteryTel");
+  console.log("batteryTel:", batteryTel);
 
-// send a control message to turn on the lights
-await client.sendControl("LightsCtrl", { lights: { value: 1 } });
+  // send a control message to change the light intensity to 1
+  await client.sendControl("LightsCtrl", { lights: { value: 1 } });
+});
 
 // subscribe to battery telemetry updates
 client.on("BatteryTel", data => {
   console.log("received BatteryTel:", data);
 });
+
+client.connect();
 ```

package/dist/example.js

@@ -3,17 +3,20 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const index_1 = require("./index");
 const main = async () => {
     const client = new index_1.BlueyeClient();
-    // request battery information
-    const batteryRep = await client.sendRequest("GetBatteryReq");
-    console.log("batteryRep:", batteryRep);
-    // get latest battery telemetry
-    const batteryTel = await client.getTelemetry("BatteryTel");
-    console.log("batteryTel:", batteryTel);
-    // send a control message to turn on the lights
-    await client.sendControl("LightsCtrl", { lights: { value: 1 } });
+    client.on("connected", async () => {
+        // request battery information
+        const batteryRep = await client.sendRequest("GetBatteryReq");
+        console.log("batteryRep:", batteryRep);
+        // get latest battery telemetry
+        const batteryTel = await client.getTelemetry("BatteryTel");
+        console.log("batteryTel:", batteryTel);
+        // send a control message to change the light intensity to 1
+        await client.sendControl("LightsCtrl", { lights: { value: 1 } });
+    });
     // subscribe to battery telemetry updates
     client.on("BatteryTel", data => {
         console.log("received BatteryTel:", data);
     });
+    client.connect();
 };
 main();

package/dist/src/client.d.ts

@@ -13,18 +13,37 @@ export type MsgHandler<T extends Req | Ctrl> = Protocol[T];
 export type CreateArgs<T extends Req | Ctrl> = Parameters<MsgHandler<T>["create"]>[0];
 export type DecodedOutput<T extends Req> = ReturnType<ReqToRep<T>["decode"]>;
 export type DecodedTelOutput<T extends Tel> = ReturnType<Protocol[T]["decode"]>;
+type State = "connecting" | "connected" | "disconnected";
 export type Events = {
+    [K in State]: [];
+} & {
     [K in Tel]: [DecodedTelOutput<K>];
 };
 export declare const isInProtocol: (key: string) => key is keyof typeof blueye.protocol;
+type Options = Partial<{
+    subUrl: string;
+    rpcUrl: string;
+    pubUrl: string;
+    timeout: number;
+    logLevel: LogLevel;
+    autoConnect: boolean;
+}>;
 export declare class BlueyeClient extends Emitter<Events> {
+    state: State;
     timeout: number;
+    private subUrl;
+    private rpcUrl;
+    private pubUrl;
     private sub;
     private rpc;
     private pub;
     private logger;
-    constructor(timeout?: number, logLevel?: LogLevel);
+    constructor({ subUrl, rpcUrl, pubUrl, timeout, logLevel, autoConnect }?: Options);
+    private updateState;
+    connect(): void;
+    disconnect(): void;
     sendRequest<T extends Req>(req: T, opts?: CreateArgs<T>): Promise<DecodedOutput<T> | null>;
     getTelemetry<T extends Tel>(type: T): Promise<DecodedTelOutput<T>>;
     sendControl<T extends Ctrl>(ctrl: T, opts?: CreateArgs<T>): Promise<void>;
 }
+export {};

package/dist/src/client.js

@@ -7,30 +7,33 @@ const consola_1 = require("consola");
 const jszmq_1 = require("jszmq");
 const strict_event_emitter_1 = require("strict-event-emitter");
 const schema_1 = require("./schema");
-const SUB_URL = "ws://192.168.1.101:9985";
-const RPC_URL = "ws://192.168.1.101:9986";
-const PUB_URL = "ws://192.168.1.101:9987";
+const DEFAULT_SUB_URL = "ws://192.168.1.101:9985";
+const DEFAULT_RPC_URL = "ws://192.168.1.101:9986";
+const DEFAULT_PUB_URL = "ws://192.168.1.101:9987";
 const isInProtocol = (key) => {
     return key in protocol_definitions_1.blueye.protocol;
 };
 exports.isInProtocol = isInProtocol;
 class BlueyeClient extends strict_event_emitter_1.Emitter {
+    state = "disconnected";
     timeout;
+    subUrl;
+    rpcUrl;
+    pubUrl;
     sub;
     rpc;
     pub;
     logger;
-    constructor(timeout = 2000, logLevel = consola_1.LogLevels.info) {
+    constructor({ subUrl = DEFAULT_SUB_URL, rpcUrl = DEFAULT_RPC_URL, pubUrl = DEFAULT_PUB_URL, timeout = 2000, logLevel = consola_1.LogLevels.info, autoConnect = false } = {}) {
         super();
         this.timeout = timeout;
         this.logger = (0, consola_1.createConsola)({ level: logLevel, formatOptions: { colors: true, compact: false } });
+        this.subUrl = subUrl;
+        this.rpcUrl = rpcUrl;
+        this.pubUrl = pubUrl;
         this.sub = new jszmq_1.Sub();
         this.rpc = new jszmq_1.Req();
         this.pub = new jszmq_1.Pub();
-        this.sub.subscribe("");
-        this.sub.connect(SUB_URL);
-        this.rpc.connect(RPC_URL);
-        this.pub.connect(PUB_URL);
         // @ts-ignore
         this.sub.on("message", (topic, msg) => {
             const { key, data } = schema_1.responseSchema.parse({ key: topic, data: msg });
@@ -43,6 +46,45 @@ class BlueyeClient extends strict_event_emitter_1.Emitter {
             this.logger.verbose("[sub] message:", key, message);
             this.emit(key, message);
         });
+        if (autoConnect) {
+            this.connect();
+        }
+    }
+    updateState(newState) {
+        this.state = newState;
+        this.logger.info(`[client] ${newState}`);
+        this.emit(newState);
+    }
+    connect() {
+        if (this.state === "connected") {
+            this.logger.warn("[client] already connected");
+            return;
+        }
+        if (this.state === "connecting") {
+            this.logger.warn("[client] already connecting");
+            return;
+        }
+        this.updateState("connecting");
+        this.sub.subscribe("");
+        this.sub.connect(this.subUrl);
+        this.rpc.connect(this.rpcUrl);
+        this.pub.connect(this.pubUrl);
+        this.updateState("connected");
+    }
+    disconnect() {
+        if (this.state === "disconnected") {
+            this.logger.warn("[client] already disconnected");
+            return;
+        }
+        if (this.state === "connecting") {
+            this.logger.warn("[client] cannot disconnect while connecting");
+            return;
+        }
+        this.sub.unsubscribe("");
+        this.sub.disconnect(this.subUrl);
+        this.rpc.disconnect(this.rpcUrl);
+        this.pub.disconnect(this.pubUrl);
+        this.updateState("disconnected");
     }
     async sendRequest(req, opts = {}) {
         if (!(0, exports.isInProtocol)(req) || !req.endsWith("Req")) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blueyerobotics/blueye-ts",
-  "version": "2.0.0",
+  "version": "3.0.0",
   "description": "A TypeScript client for interacting with Blueye underwater drones.",
   "repository": {
     "type": "git",