@blueyerobotics/blueye-ts 3.4.0 → 3.6.0

package/README.md

@@ -1,6 +1,6 @@
 # blueye-ts
 
-A TypeScript client for interacting with Blueye underwater drones.
+A TypeScript package for interacting with Blueye underwater drones and parsing binlog files.
 
 ## Installation
 

package/dist/index.d.ts

@@ -1,3 +1,4 @@
 export * from "@blueyerobotics/protocol-definitions";
+export * from "./src/binlog-parser";
 export * from "./src/client";
 export * from "./src/schema";

package/dist/index.js

@@ -15,5 +15,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("@blueyerobotics/protocol-definitions"), exports);
+__exportStar(require("./src/binlog-parser"), exports);
 __exportStar(require("./src/client"), exports);
 __exportStar(require("./src/schema"), exports);

package/dist/src/async-queue.d.ts

@@ -0,0 +1,4 @@
+export declare class AsyncQueue {
+    private lastPromise;
+    enqueue<T>(fn: () => Promise<T>): Promise<T>;
+}

package/dist/src/async-queue.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AsyncQueue = void 0;
+class AsyncQueue {
+    lastPromise = Promise.resolve();
+    enqueue(fn) {
+        const run = this.lastPromise.then(() => fn());
+        this.lastPromise = run.finally(() => { });
+        return run;
+    }
+}
+exports.AsyncQueue = AsyncQueue;

package/dist/src/binlog-parser.d.ts

@@ -0,0 +1,38 @@
+import { Buffer } from "buffer";
+import { type Protocol, type ProtocolKey, type ProtocolType } from "./client";
+export type Message = {
+    [K in ProtocolKey]: {
+        monotonicTime: number;
+        time: number;
+        type: ProtocolType;
+        key: K;
+        data: ReturnType<Protocol[K]["decode"]>;
+        innerData?: object;
+    };
+}[ProtocolKey];
+/**
+ * Parse a binlog file from raw (gzipped) data into structured messages..
+ * @param rawData The raw binary data of the binlog file (gzip format).
+ * @param fixTimes Fix the message times based on the last message's monotonic and unix timestamps. Useful for ensuring the times are in sync.
+ * @returns A promise that resolves to an array of parsed messages.
+ */
+export declare const parse: (rawData: Blob, fixTimes?: boolean) => Promise<Message[]>;
+/**
+ * Decompress the gzipped binlog data (.bez).
+ * @param rawData The compressed binary data to decompress (gzip format).
+ * @returns A promise that resolves to the decompressed data as a Buffer.
+ */
+export declare const decompress: (rawData: Blob) => Promise<Buffer>;
+/**
+ * Parse the decompressed binlog data into structured messages.
+ * @param decompressed The gunzipped binlog data.
+ * @param fixTimes Fix the message times based on the last message's monotonic and unix timestamps. Useful for ensuring the times are in sync.
+ * @returns An array of parsed messages with their timestamps, types, keys, and data.
+ */
+export declare const parseMessages: (decompressed: Uint8Array, fixTimes?: boolean) => Message[];
+/**
+ * Fix the message times based on the last message's monotonic and unix timestamps.
+ * @param messages The messages to fix the times for.
+ * @returns The messages with corrected times.
+ */
+export declare const fixMessageTimes: (messages: Message[]) => Message[];

package/dist/src/binlog-parser.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fixMessageTimes = exports.parseMessages = exports.decompress = exports.parse = void 0;
+const protocol_definitions_1 = require("@blueyerobotics/protocol-definitions");
+const wire_1 = require("@bufbuild/protobuf/wire");
+const buffer_1 = require("buffer");
+const fflate_1 = require("fflate");
+const client_1 = require("./client");
+/**
+ * Parse a binlog file from raw (gzipped) data into structured messages..
+ * @param rawData The raw binary data of the binlog file (gzip format).
+ * @param fixTimes Fix the message times based on the last message's monotonic and unix timestamps. Useful for ensuring the times are in sync.
+ * @returns A promise that resolves to an array of parsed messages.
+ */
+const parse = async (rawData, fixTimes = true) => {
+    const decompressed = await (0, exports.decompress)(rawData);
+    const messages = (0, exports.parseMessages)(decompressed, fixTimes);
+    return messages;
+};
+exports.parse = parse;
+/**
+ * Decompress the gzipped binlog data (.bez).
+ * @param rawData The compressed binary data to decompress (gzip format).
+ * @returns A promise that resolves to the decompressed data as a Buffer.
+ */
+const decompress = async (rawData) => {
+    const gunzip = new fflate_1.Gunzip();
+    const blobReader = rawData.stream().getReader();
+    const chunks = [];
+    gunzip.ondata = (chunk) => {
+        chunks.push(chunk);
+    };
+    while (true) {
+        const { done, value } = await blobReader.read();
+        if (done) {
+            try {
+                gunzip.push(new Uint8Array(0), true);
+            }
+            catch (err) {
+                console.error("Error pushing end-of-stream marker:", err);
+            }
+            break;
+        }
+        gunzip.push(value);
+    }
+    return buffer_1.Buffer.concat(chunks);
+};
+exports.decompress = decompress;
+/**
+ * Parse the decompressed binlog data into structured messages.
+ * @param decompressed The gunzipped binlog data.
+ * @param fixTimes Fix the message times based on the last message's monotonic and unix timestamps. Useful for ensuring the times are in sync.
+ * @returns An array of parsed messages with their timestamps, types, keys, and data.
+ */
+const parseMessages = (decompressed, fixTimes = true) => {
+    const reader = new wire_1.BinaryReader(decompressed);
+    let messages = [];
+    while (reader.pos < reader.len) {
+        const length = reader.uint32();
+        const start = reader.pos;
+        const end = start + length;
+        if (end > reader.len) {
+            console.error("Unexpected EOF while reading message bytes");
+            break;
+        }
+        const msgBytes = decompressed.buffer.slice(start, end);
+        reader.pos = end;
+        const msg = protocol_definitions_1.blueye.protocol.BinlogRecord.decode(new Uint8Array(msgBytes), length);
+        const key = msg.payload.typeUrl.split(".").at(-1);
+        if (!key || !(0, client_1.isInProtocol)(key)) {
+            console.warn(`Unknown protocol key: ${key}`);
+            continue;
+        }
+        const data = protocol_definitions_1.blueye.protocol[key].decode(msg.payload.value);
+        let innerData;
+        if (key === "GetTelemetryRep") {
+            const telRep = data;
+            const innerKey = telRep.payload?.typeUrl.split(".").at(-1);
+            if (!innerKey || !(0, client_1.isInProtocol)(innerKey)) {
+                console.warn(`Unknown inner protocol key: ${innerKey}`);
+                continue;
+            }
+            innerData = protocol_definitions_1.blueye.protocol[innerKey].decode(telRep.payload.value);
+        }
+        let type = "Tel";
+        if (key.endsWith("Ctrl"))
+            type = "Ctrl";
+        else if (key.endsWith("Rep"))
+            type = "Rep";
+        else if (key.endsWith("Req"))
+            type = "Req";
+        // @ts-expect-error 2345
+        messages.push({
+            monotonicTime: msg.clockMonotonic.getTime(),
+            time: msg.unixTimestamp.getTime(),
+            type,
+            key,
+            data,
+            innerData,
+        });
+    }
+    if (fixTimes) {
+        messages = (0, exports.fixMessageTimes)(messages);
+    }
+    return messages;
+};
+exports.parseMessages = parseMessages;
+/**
+ * Fix the message times based on the last message's monotonic and unix timestamps.
+ * @param messages The messages to fix the times for.
+ * @returns The messages with corrected times.
+ */
+const fixMessageTimes = (messages) => {
+    if (messages.length === 0)
+        return messages;
+    const last = messages.at(-1);
+    const ssbLast = last.monotonicTime;
+    const unixLast = last.time;
+    for (const message of messages) {
+        const delta = ssbLast - message.monotonicTime;
+        message.time = unixLast - delta;
+    }
+    return messages;
+};
+exports.fixMessageTimes = fixMessageTimes;

package/dist/src/client.d.ts

@@ -1,5 +1,5 @@
 import { blueye } from "@blueyerobotics/protocol-definitions";
-import { LogLevel } from "consola";
+import { type LogLevel } from "consola";
 import { Emitter } from "strict-event-emitter";
 export type Protocol = typeof blueye.protocol;
 export type ProtocolType = "Req" | "Rep" | "Tel" | "Ctrl";
@@ -25,20 +25,23 @@ type Options = Partial<{
     rpcUrl: string;
     pubUrl: string;
     timeout: number;
+    reconnectInterval: number;
     logLevel: LogLevel;
     autoConnect: boolean;
 }>;
 export declare class BlueyeClient extends Emitter<Events> {
     state: State;
     timeout: number;
+    reconnectInterval: number;
     private subUrl;
     private rpcUrl;
     private pubUrl;
     private sub;
     private rpc;
     private pub;
+    private queue;
     private logger;
-    constructor({ subUrl, rpcUrl, pubUrl, timeout, logLevel, autoConnect, }?: Options);
+    constructor({ subUrl, rpcUrl, pubUrl, timeout, reconnectInterval, logLevel, autoConnect, }?: Options);
     private updateState;
     connect(): void;
     disconnect(): void;

package/dist/src/client.js

@@ -6,6 +6,7 @@ const buffer_1 = require("buffer");
 const consola_1 = require("consola");
 const jszmq_1 = require("jszmq");
 const strict_event_emitter_1 = require("strict-event-emitter");
+const async_queue_1 = require("./async-queue");
 const schema_1 = require("./schema");
 const DEFAULT_SUB_URL = "ws://192.168.1.101:9985";
 const DEFAULT_RPC_URL = "ws://192.168.1.101:9986";
@@ -17,26 +18,30 @@ exports.isInProtocol = isInProtocol;
 class BlueyeClient extends strict_event_emitter_1.Emitter {
     state = "disconnected";
     timeout;
+    reconnectInterval;
     subUrl;
     rpcUrl;
     pubUrl;
     sub;
     rpc;
     pub;
+    queue;
     logger;
-    constructor({ subUrl = DEFAULT_SUB_URL, rpcUrl = DEFAULT_RPC_URL, pubUrl = DEFAULT_PUB_URL, timeout = 2000, logLevel = consola_1.LogLevels.info, autoConnect = false, } = {}) {
+    constructor({ subUrl = DEFAULT_SUB_URL, rpcUrl = DEFAULT_RPC_URL, pubUrl = DEFAULT_PUB_URL, timeout = 2000, reconnectInterval = 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.reconnectInterval = reconnectInterval;
         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.queue = new async_queue_1.AsyncQueue();
+        this.logger = (0, consola_1.createConsola)({
+            level: logLevel,
+            formatOptions: { colors: true, compact: false },
+        });
         // @ts-ignore
         this.sub.on("message", (topic, msg) => {
             const { key, data } = schema_1.responseSchema.parse({ key: topic, data: msg });
@@ -67,6 +72,9 @@ class BlueyeClient extends strict_event_emitter_1.Emitter {
             this.logger.warn("[client] already connecting");
             return;
         }
+        this.sub.options.reconnectInterval = this.reconnectInterval;
+        this.rpc.options.reconnectInterval = this.reconnectInterval;
+        this.pub.options.reconnectInterval = this.reconnectInterval;
         this.updateState("connecting");
         this.sub.subscribe("");
         this.sub.connect(this.subUrl);
@@ -96,19 +104,21 @@ class BlueyeClient extends strict_event_emitter_1.Emitter {
         const protocol = protocol_definitions_1.blueye.protocol[req];
         const message = protocol.create(opts);
         const encoded = protocol.encode(message).finish();
-        const { key, data } = await Promise.race([
-            new Promise((_, reject) => setTimeout(() => reject(new Error("[rpc] request timed out")), this.timeout)),
-            new Promise((resolve) => {
+        const request = () => {
+            return new Promise((resolve, reject) => {
+                const timer = setTimeout(() => reject(new Error("[rpc] request timed out")), this.timeout);
                 // @ts-ignore
                 this.rpc.once("message", (topic, msg) => {
+                    clearTimeout(timer);
                     resolve({ key: topic.toString().split(".").at(-1), data: msg });
                 });
                 this.rpc.send([
                     buffer_1.Buffer.from(`blueye.protocol.${req}`),
                     buffer_1.Buffer.from(encoded),
                 ]);
-            }),
-        ]);
+            });
+        };
+        const { key, data } = await this.queue.enqueue(request);
         if (key === "Empty") {
             return null;
         }

package/dist/src/schema.d.ts

@@ -1,34 +1,12 @@
 import { Buffer } from "buffer";
 import z from "zod";
 export declare const responseSchema: z.ZodObject<{
-    key: z.ZodEffects<z.ZodType<Buffer, z.ZodTypeDef, Buffer>, string, Buffer>;
-    data: z.ZodType<Buffer, z.ZodTypeDef, Buffer>;
-}, "strip", z.ZodTypeAny, {
-    key: string;
-    data: Buffer;
-}, {
-    key: Buffer;
-    data: Buffer;
-}>;
+    key: z.ZodPipe<z.ZodCustom<Buffer, Buffer>, z.ZodTransform<string, Buffer>>;
+    data: z.ZodCustom<Buffer, Buffer>;
+}, z.core.$strip>;
 export declare const telemetrySchema: z.ZodObject<{
     payload: z.ZodObject<{
-        typeUrl: z.ZodEffects<z.ZodString, string, string>;
-        value: z.ZodEffects<z.ZodEffects<z.ZodAny, Buffer | Uint8Array<ArrayBufferLike>, any>, Buffer, any>;
-    }, "strip", z.ZodTypeAny, {
-        value: Buffer;
-        typeUrl: string;
-    }, {
-        typeUrl: string;
-        value?: any;
-    }>;
-}, "strip", z.ZodTypeAny, {
-    payload: {
-        value: Buffer;
-        typeUrl: string;
-    };
-}, {
-    payload: {
-        typeUrl: string;
-        value?: any;
-    };
-}>;
+        typeUrl: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
+        value: z.ZodPipe<z.ZodAny, z.ZodTransform<Buffer, any>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;

package/dist/src/schema.js

@@ -7,15 +7,17 @@ exports.telemetrySchema = exports.responseSchema = void 0;
 const buffer_1 = require("buffer");
 const zod_1 = __importDefault(require("zod"));
 exports.responseSchema = zod_1.default.object({
-    key: zod_1.default.instanceof(buffer_1.Buffer).transform(val => val.toString().split(".").at(-1)),
-    data: zod_1.default.instanceof(buffer_1.Buffer)
+    key: zod_1.default
+        .instanceof(buffer_1.Buffer)
+        .transform((val) => val.toString().split(".").at(-1)),
+    data: zod_1.default.instanceof(buffer_1.Buffer),
 });
 exports.telemetrySchema = zod_1.default.object({
     payload: zod_1.default.object({
-        typeUrl: zod_1.default.string().transform(val => val.split(".").at(-1)),
+        typeUrl: zod_1.default.string().transform((val) => val.split(".").at(-1)),
         value: zod_1.default
             .any()
-            .refine(val => val instanceof buffer_1.Buffer || val instanceof Uint8Array)
-            .transform(val => (buffer_1.Buffer.isBuffer(val) ? val : buffer_1.Buffer.from(val)))
-    })
+            .refine((val) => val instanceof buffer_1.Buffer || val instanceof Uint8Array)
+            .transform((val) => (buffer_1.Buffer.isBuffer(val) ? val : buffer_1.Buffer.from(val))),
+    }),
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blueyerobotics/blueye-ts",
-  "version": "3.4.0",
+  "version": "3.6.0",
   "description": "A TypeScript client for interacting with Blueye underwater drones.",
   "repository": {
     "type": "git",
@@ -16,14 +16,17 @@
   "license": "LGPL-3.0-only",
   "dependencies": {
     "@blueyerobotics/protocol-definitions": "3.2.0-b1918def",
+    "@bufbuild/protobuf": "^2.10.0",
     "buffer": "^6.0.3",
     "consola": "^3.4.2",
+    "fflate": "^0.8.2",
     "jszmq": "^0.1.2",
     "strict-event-emitter": "^0.5.1",
-    "zod": "^3.25.67"
+    "zod": "^4.1.12"
   },
   "devDependencies": {
-    "typescript": "^5.9.2"
+    "@biomejs/biome": "2.3.2",
+    "typescript": "^5.9.3"
   },
   "scripts": {
     "start": "node dist/example.js",