@blueyerobotics/blueye-ts 3.5.0 → 3.7.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/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,132 @@
+"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;
+        }
+        if (msg.payload == null) {
+            console.warn(`Missing payload for 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 = telRep.payload
+                ? protocol_definitions_1.blueye.protocol[innerKey].decode(telRep.payload.value)
+                : undefined;
+        }
+        let type = "Tel";
+        if (key.endsWith("Ctrl"))
+            type = "Ctrl";
+        else if (key.endsWith("Rep"))
+            type = "Rep";
+        else if (key.endsWith("Req"))
+            type = "Req";
+        messages.push({
+            monotonicTime: msg.clockMonotonic?.getTime() ?? 0,
+            time: msg.unixTimestamp?.getTime() ?? 0,
+            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);
+    if (!last)
+        return messages;
+    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,12 +25,14 @@ 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;
@@ -39,7 +41,7 @@ export declare class BlueyeClient extends Emitter<Events> {
     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

@@ -18,6 +18,7 @@ exports.isInProtocol = isInProtocol;
 class BlueyeClient extends strict_event_emitter_1.Emitter {
     state = "disconnected";
     timeout;
+    reconnectInterval;
     subUrl;
     rpcUrl;
     pubUrl;
@@ -26,9 +27,10 @@ class BlueyeClient extends strict_event_emitter_1.Emitter {
     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.reconnectInterval = reconnectInterval;
         this.subUrl = subUrl;
         this.rpcUrl = rpcUrl;
         this.pubUrl = pubUrl;
@@ -70,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);
@@ -100,9 +105,11 @@ class BlueyeClient extends strict_event_emitter_1.Emitter {
         const message = protocol.create(opts);
         const encoded = protocol.encode(message).finish();
         const request = () => {
-            return new Promise((resolve) => {
+            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([
@@ -111,10 +118,7 @@ class BlueyeClient extends strict_event_emitter_1.Emitter {
                 ]);
             });
         };
-        const { key, data } = await Promise.race([
-            new Promise((_, reject) => setTimeout(() => reject(new Error("[rpc] request timed out")), this.timeout)),
-            this.queue.enqueue(request),
-        ]);
+        const { key, data } = await this.queue.enqueue(request);
         if (key === "Empty") {
             return null;
         }

package/dist/src/schema.d.ts

@@ -7,6 +7,6 @@ export declare const responseSchema: z.ZodObject<{
 export declare const telemetrySchema: z.ZodObject<{
     payload: z.ZodObject<{
         typeUrl: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
-        value: z.ZodPipe<z.ZodAny, z.ZodTransform<Buffer, any>>;
+        value: z.ZodPipe<z.ZodAny & z.ZodType<Buffer | Uint8Array<ArrayBufferLike>, any, z.core.$ZodTypeInternals<Buffer | Uint8Array<ArrayBufferLike>, any>>, 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.5.0",
+  "version": "3.7.0",
   "description": "A TypeScript client for interacting with Blueye underwater drones.",
   "repository": {
     "type": "git",
@@ -15,14 +15,17 @@
   "author": "Blueye <contact@blueye.no> (https://blueye.no/)",
   "license": "LGPL-3.0-only",
   "dependencies": {
-    "@blueyerobotics/protocol-definitions": "3.2.0-b1918def",
+    "@blueyerobotics/protocol-definitions": "3.2.0-c75f3166",
+    "@bufbuild/protobuf": "^2.10.2",
     "buffer": "^6.0.3",
     "consola": "^3.4.2",
+    "fflate": "^0.8.2",
     "jszmq": "^0.1.2",
     "strict-event-emitter": "^0.5.1",
-    "zod": "^4.1.12"
+    "zod": "^4.3.5"
   },
   "devDependencies": {
+    "@biomejs/biome": "2.3.11",
     "typescript": "^5.9.3"
   },
   "scripts": {