@blueyerobotics/blueye-ts 4.0.3 → 5.0.0

package/dist/src/sonar-device.js

@@ -0,0 +1,34 @@
+import * as semver from "semver";
+export const MULTIBEAM_DEVICE_IDS = [13, 16, 18, 20, 29, 30, 41, 42];
+const GUEST_PORTS = ["gp1", "gp2", "gp3"];
+/**
+ * The sonar telemetry endpoint exists on Blunux >= 4.7.0; "-dev" builds are
+ * assumed to be newer than any release.
+ */
+export const hasSonarEndpoint = (version) => {
+    const coercedVersion = semver.coerce(version);
+    return coercedVersion
+        ? semver.satisfies(coercedVersion, ">=4.7.0") || version.endsWith("-dev")
+        : false;
+};
+/**
+ * Decide from a DroneInfoTel whether a multibeam sonar is connected and
+ * reachable: the firmware must expose the sonar endpoint and a known
+ * multibeam device ID must be present in one of the guest-port device lists.
+ * Pure — no sockets, no side effects.
+ */
+export const detectSonar = (msg) => {
+    const version = msg.droneInfo?.blunuxVersion;
+    if (!hasSonarEndpoint(version ?? "")) {
+        return { detected: false, reason: "incompatible-firmware", version };
+    }
+    for (const port of GUEST_PORTS) {
+        const devices = msg.droneInfo?.gp?.[port]?.deviceList?.devices ?? [];
+        for (const device of devices) {
+            if (MULTIBEAM_DEVICE_IDS.includes(device.deviceId)) {
+                return { detected: true, deviceId: device.deviceId };
+            }
+        }
+    }
+    return { detected: false, reason: "no-multibeam-device" };
+};

package/dist/src/transport.d.ts

@@ -0,0 +1,31 @@
+export type SocketKind = "sub" | "req" | "pub";
+export type TransportFrame = Uint8Array | string;
+export type TransportEvents = {
+    ready: [];
+    lost: [];
+    message: [topic: Uint8Array<ArrayBuffer>, payload: Uint8Array<ArrayBuffer>];
+};
+export type TransportSocket = {
+    connect(url: string): void;
+    disconnect(url: string): void;
+    close(): void;
+    /**
+     * Force-drop the live connection(s) without forgetting the endpoints:
+     * emits "lost" and lets the transport's normal reconnect machinery try to
+     * re-establish. Used to convert silently-dead links into explicit loss.
+     */
+    dropConnection(): void;
+    send(frames: TransportFrame[]): void;
+    subscribe(topic: string): void;
+    unsubscribe(topic: string): void;
+    setReconnectInterval(ms: number): void;
+    on<E extends keyof TransportEvents>(event: E, listener: (...args: TransportEvents[E]) => void): void;
+    once<E extends keyof TransportEvents>(event: E, listener: (...args: TransportEvents[E]) => void): void;
+    off<E extends keyof TransportEvents>(event: E, listener: (...args: TransportEvents[E]) => void): void;
+};
+export type Transport = {
+    createSocket(kind: SocketKind): TransportSocket;
+};
+export declare class JszmqTransport implements Transport {
+    createSocket(kind: SocketKind): TransportSocket;
+}

package/dist/src/transport.js

@@ -0,0 +1,69 @@
+import { Pub as JszmqPub, Req as JszmqReq, Sub as JszmqSub, } from "@blueyerobotics/jszmq";
+class JszmqSocket {
+    socket;
+    constructor(socket) {
+        this.socket = socket;
+        // A jszmq REQ socket is lockstep: once a request is sent it refuses to
+        // send another until the reply arrives, and that flag survives connection
+        // loss — wedging the socket forever if the server died mid-request.
+        // Losing the connection means the reply can no longer arrive, so reset.
+        if (socket instanceof JszmqReq) {
+            socket.on("lost", () => {
+                socket.receivingReply = false;
+            });
+        }
+    }
+    connect(url) {
+        this.socket.connect(url);
+    }
+    disconnect(url) {
+        this.socket.disconnect(url);
+    }
+    close() {
+        this.socket.close();
+    }
+    dropConnection() {
+        // Close each endpoint's raw WebSocket while leaving the endpoint
+        // registered: jszmq treats an unexpected close as a loss — it emits
+        // "lost" and schedules its own reconnect (webSocketEndpoint.onClose).
+        // endpoint.close()/disconnect(url) would instead terminate the endpoint
+        // permanently, which is exactly what we don't want here.
+        const { endpoints } = this.socket;
+        for (const endpoint of endpoints ?? []) {
+            endpoint.socket?.close();
+        }
+    }
+    send(frames) {
+        this.socket.send(frames);
+    }
+    subscribe(topic) {
+        this.socket.subscribe(topic);
+    }
+    unsubscribe(topic) {
+        this.socket.unsubscribe(topic);
+    }
+    setReconnectInterval(ms) {
+        this.socket.options.reconnectInterval = ms;
+    }
+    on(event, listener) {
+        this.socket.on(event, listener);
+    }
+    once(event, listener) {
+        this.socket.once(event, listener);
+    }
+    off(event, listener) {
+        this.socket.removeListener(event, listener);
+    }
+}
+export class JszmqTransport {
+    createSocket(kind) {
+        switch (kind) {
+            case "sub":
+                return new JszmqSocket(new JszmqSub());
+            case "req":
+                return new JszmqSocket(new JszmqReq());
+            case "pub":
+                return new JszmqSocket(new JszmqPub());
+        }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blueyerobotics/blueye-ts",
-  "version": "4.0.3",
+  "version": "5.0.0",
   "description": "A TypeScript client for interacting with Blueye underwater drones.",
   "repository": {
     "type": "git",
@@ -21,21 +21,20 @@
   "license": "LGPL-3.0-only",
   "dependencies": {
     "@blueyerobotics/jszmq": "^0.3.0",
-    "@blueyerobotics/protocol-definitions": "3.2.0-2e3e3a62",
-    "@bufbuild/protobuf": "^2.11.0",
+    "@blueyerobotics/protocol-definitions": "3.2.0-d6c9260a",
+    "@bufbuild/protobuf": "^2.13.0",
     "consola": "^3.4.2",
-    "fflate": "^0.8.2",
-    "semver": "^7.7.4",
-    "strict-event-emitter": "^0.5.1",
-    "zod": "^4.3.6"
+    "fflate": "^0.8.3",
+    "semver": "^7.8.5",
+    "strict-event-emitter": "^0.5.1"
   },
   "devDependencies": {
-    "@biomejs/biome": "2.3.14",
-    "@types/node": "^25.4.0",
+    "@biomejs/biome": "2.5.6",
+    "@types/node": "^26.1.2",
     "@types/semver": "^7.7.1",
-    "tsx": "^4.20.7",
-    "typescript": "^5.9.3",
-    "vitest": "^4.0.5"
+    "tsx": "^4.23.1",
+    "typescript": "^7.0.2",
+    "vitest": "^4.1.10"
   },
   "scripts": {
     "start": "tsx example.ts",

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

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

package/dist/src/async-queue.js

@@ -1,8 +0,0 @@
-export class AsyncQueue {
-    lastPromise = Promise.resolve();
-    enqueue(fn) {
-        const run = this.lastPromise.then(() => fn());
-        this.lastPromise = run.finally(() => { });
-        return run;
-    }
-}

package/dist/src/schema.d.ts

@@ -1,11 +0,0 @@
-import z from "zod";
-export declare const responseSchema: z.ZodObject<{
-    key: z.ZodPipe<z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>, z.ZodTransform<string, Uint8Array<ArrayBuffer>>>;
-    data: z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>;
-}, z.core.$strip>;
-export declare const telemetrySchema: z.ZodObject<{
-    payload: z.ZodObject<{
-        typeUrl: z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>;
-        value: z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>;
-    }, z.core.$strip>;
-}, z.core.$strip>;

package/dist/src/schema.js

@@ -1,14 +0,0 @@
-import z from "zod";
-const utf8 = new TextDecoder();
-export const responseSchema = z.object({
-    key: z
-        .instanceof(Uint8Array)
-        .transform((val) => utf8.decode(val).split(".").at(-1) ?? ""),
-    data: z.instanceof(Uint8Array),
-});
-export const telemetrySchema = z.object({
-    payload: z.object({
-        typeUrl: z.string().transform((val) => val.split(".").at(-1) ?? ""),
-        value: z.instanceof(Uint8Array),
-    }),
-});