@blueyerobotics/blueye-ts 1.0.0 → 1.1.0

package/dist/src/client.d.ts

@@ -20,9 +20,9 @@ export declare class BlueyeClient {
     private wsReqRep;
     private isReqRepConnected;
     private logger;
+    private pendingRequests;
     sub: Emitter<Events>;
     constructor(logLevel?: LogLevel);
-    private send;
     sendRequest<T extends Req>(req: T, opts?: CreateArgs<T>): Promise<DecodedOutput<T> | null>;
     getTelemetry<T extends Tel>(type: T): Promise<DecodedTelOutput<T>>;
 }

package/dist/src/client.js

@@ -5,6 +5,7 @@ const protocol_definitions_1 = require("@blueyerobotics/protocol-definitions");
 const buffer_1 = require("buffer");
 const consola_1 = require("consola");
 const strict_event_emitter_1 = require("strict-event-emitter");
+const uuid_1 = require("uuid");
 const schema_1 = require("./schema");
 const WS_PUBSUB_URL = "ws://localhost:8765";
 const WS_REQREP_URL = "ws://localhost:8766";
@@ -17,6 +18,7 @@ class BlueyeClient {
     wsReqRep;
     isReqRepConnected = false;
     logger;
+    pendingRequests = new Map();
     sub = new strict_event_emitter_1.Emitter();
     constructor(logLevel = consola_1.LogLevels.info) {
         this.logger = (0, consola_1.createConsola)({ level: logLevel, formatOptions: { colors: true, compact: false } });
@@ -36,41 +38,36 @@ class BlueyeClient {
             this.logger.verbose("[WS] PubSub message:", key, message);
             this.sub.emit(key, message);
         });
-    }
-    async send(data) {
-        while (!this.isReqRepConnected) {
-            this.logger.debug("Waiting...");
-            await new Promise(res => setTimeout(res, 50));
-        }
-        return await new Promise((resolve, reject) => {
-            const onMessage = (event) => {
-                cleanUp();
-                resolve(event.data);
-            };
-            const onError = (error) => {
-                cleanUp();
-                this.logger.error("[WS] Error:", error);
-                reject(error);
-            };
-            const cleanUp = () => {
-                this.wsReqRep.removeEventListener("message", onMessage);
-                this.wsReqRep.removeEventListener("error", onError);
-            };
-            this.wsReqRep.addEventListener("message", onMessage);
-            this.wsReqRep.addEventListener("error", onError);
-            this.wsReqRep.send(data);
+        this.wsReqRep.addEventListener("message", event => {
+            this.logger.debug("Response:", event.data);
+            const { id, key, data } = schema_1.responseSchema.parse(JSON.parse(event.data));
+            if (!id)
+                throw new Error("Response id is missing");
+            this.pendingRequests.get(id)?.({ key, data });
+            this.pendingRequests.delete(id);
         });
     }
     async sendRequest(req, opts = {}) {
         const protocol = protocol_definitions_1.blueye.protocol[req];
         const message = protocol.create(opts);
         const encoded = protocol.encode(message).finish();
-        const response = await this.send(JSON.stringify({
-            key: `blueye.protocol.${req}`,
-            data: buffer_1.Buffer.from(encoded).toString("base64")
-        }));
-        this.logger.debug("Response:", response);
-        const { key, data } = schema_1.responseSchema.parse(JSON.parse(response));
+        while (!this.isReqRepConnected) {
+            this.logger.debug("Waiting...");
+            await new Promise(res => setTimeout(res, 50));
+        }
+        const { key, data } = await Promise.race([
+            new Promise((_, reject) => setTimeout(() => reject(new Error("Request timed out")), 2000)),
+            new Promise(resolve => {
+                const id = (0, uuid_1.v4)();
+                const request = JSON.stringify({
+                    id,
+                    key: `blueye.protocol.${req}`,
+                    data: buffer_1.Buffer.from(encoded).toString("base64")
+                });
+                this.pendingRequests.set(id, resolve);
+                this.wsReqRep.send(request);
+            })
+        ]);
         if (key === "Empty") {
             return null;
         }

package/dist/src/schema.d.ts

@@ -1,14 +1,17 @@
 import { Buffer } from "buffer";
 import z from "zod";
 export declare const responseSchema: z.ZodObject<{
+    id: z.ZodOptional<z.ZodString>;
     key: z.ZodEffects<z.ZodString, string, string>;
     data: z.ZodEffects<z.ZodString, Buffer, string>;
 }, "strip", z.ZodTypeAny, {
     key: string;
     data: Buffer;
+    id?: string | undefined;
 }, {
     key: string;
     data: string;
+    id?: string | undefined;
 }>;
 export declare const telemetrySchema: z.ZodObject<{
     payload: z.ZodObject<{

package/dist/src/schema.js

@@ -7,6 +7,7 @@ exports.telemetrySchema = exports.responseSchema = void 0;
 const buffer_1 = require("buffer");
 const zod_1 = __importDefault(require("zod"));
 exports.responseSchema = zod_1.default.object({
+    id: zod_1.default.string().uuid().optional(),
     key: zod_1.default.string().transform(val => val.split(".").at(-1)),
     data: zod_1.default
         .string()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blueyerobotics/blueye-ts",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "A TypeScript client for interacting with Blueye underwater drones.",
   "repository": {
     "type": "git",
@@ -17,11 +17,13 @@
   },
   "keywords": [],
   "author": "Blueye <contact@blueye.no> (https://blueye.no/)",
+  "license": "LGPL-3.0-only",
   "dependencies": {
     "@blueyerobotics/protocol-definitions": "3.2.0-3e0ba702",
     "buffer": "^6.0.3",
     "consola": "^3.4.2",
     "strict-event-emitter": "^0.5.1",
+    "uuid": "^11.1.0",
     "zod": "^3.25.67"
   },
   "devDependencies": {