Use enormous union type to make message types stricter

src/RosLib.ts

@@ -78,4 +78,44 @@ export {
   isRosbridgeAdvertiseMessage,
   type RosbridgeSubscribeMessage,
   isRosbridgeSubscribeMessage,
+  type RosbridgeAuthMessage,
+  type RosbridgeStatusMessage,
+  isRosbridgeStatusMessage,
+  type RosbridgeSetStatusLevelMessage,
+  isRosbridgeSetStatusLevelMessage,
+  type RosbridgeFragmentMessage,
+  isRosbridgeFragmentMessage,
+  type RosbridgePngMessage,
+  isRosbridgePngMessage,
+  type RosbridgeUnadvertiseMessage,
+  isRosbridgeUnadvertiseMessage,
+  type RosbridgePublishMessage,
+  isRosbridgePublishMessage,
+  type RosbridgeUnsubscribeMessage,
+  isRosbridgeUnsubscribeMessage,
+  type RosbridgeAdvertiseServiceMessage,
+  isRosbridgeAdvertiseServiceMessage,
+  type RosbridgeUnadvertiseServiceMessage,
+  isRosbridgeUnadvertiseServiceMessage,
+  type RosbridgeCallServiceMessage,
+  isRosbridgeCallServiceMessage,
+  type RosbridgeServiceResponseMessage,
+  isRosbridgeServiceResponseMessage,
+  type RosbridgeAdvertiseActionMessage,
+  isRosbridgeAdvertiseActionMessage,
+  type RosbridgeUnadvertiseActionMessage,
+  isRosbridgeUnadvertiseActionMessage,
+  type RosbridgeSendActionGoalMessage,
+  isRosbridgeSendActionGoalMessage,
+  type RosbridgeCancelActionGoalMessage,
+  isRosbridgeCancelActionGoalMessage,
+  type RosbridgeActionFeedbackMessage,
+  isRosbridgeActionFeedbackMessage,
+  type RosbridgeActionResultMessage,
+  isRosbridgeActionResultMessage,
+  type RosbridgeMessageBase,
+  type FailedRosbridgeActionResultMessage,
+  type SuccessfulRosbridgeActionResultMessage,
+  type FailedRosbridgeServiceResponseMessage,
+  type SuccessfulRosbridgeServiceResponseMessage,
 } from "./types/protocol.js";

src/core/Action.ts

@@ -82,15 +82,14 @@ export default class Action<
       }
     });
 
-    const call = {
+    this.ros.callOnConnection({
       op: "send_action_goal",
       id: actionGoalId,
       action: this.name,
       action_type: this.actionType,
       args: goal,
       feedback: true,
-    };
-    this.ros.callOnConnection(call);
+    });
 
     return actionGoalId;
   }
@@ -101,12 +100,11 @@ export default class Action<
    * @param id - The ID of the action goal to cancel.
    */
   cancelGoal(id: string) {
-    const call = {
+    this.ros.callOnConnection({
       op: "cancel_action_goal",
       id: id,
       action: this.name,
-    };
-    this.ros.callOnConnection(call);
+    });
   }
 
   /**
@@ -200,13 +198,12 @@ export default class Action<
    * @param feedback - The feedback to send.
    */
   sendFeedback(id: string, feedback: TFeedback) {
-    const call = {
+    this.ros.callOnConnection({
       op: "action_feedback",
       id: id,
       action: this.name,
       values: feedback,
-    };
-    this.ros.callOnConnection(call);
+    });
   }
 
   /**
@@ -216,15 +213,14 @@ export default class Action<
    * @param result - The result to set.
    */
   setSucceeded(id: string, result: TResult) {
-    const call = {
+    this.ros.callOnConnection({
       op: "action_result",
       id: id,
       action: this.name,
       values: result,
       status: GoalStatus.STATUS_SUCCEEDED,
       result: true,
-    };
-    this.ros.callOnConnection(call);
+    });
   }
 
   /**
@@ -234,15 +230,14 @@ export default class Action<
    * @param result - The result to set.
    */
   setCanceled(id: string, result: TResult) {
-    const call = {
+    this.ros.callOnConnection({
       op: "action_result",
       id: id,
       action: this.name,
       values: result,
       status: GoalStatus.STATUS_CANCELED,
       result: true,
-    };
-    this.ros.callOnConnection(call);
+    });
   }
 
   /**
@@ -251,13 +246,12 @@ export default class Action<
    * @param id - The action goal ID.
    */
   setFailed(id: string) {
-    const call = {
+    this.ros.callOnConnection({
       op: "action_result",
       id: id,
       action: this.name,
       status: GoalStatus.STATUS_ABORTED,
       result: false,
-    };
-    this.ros.callOnConnection(call);
+    });
   }
 }

src/core/Ros.ts

@@ -5,6 +5,7 @@
 
 import type {
   RosbridgeMessage,
+  RosbridgeMessageBase,
   RosbridgeSetStatusLevelMessage,
 } from "../types/protocol.js";
 import {
@@ -121,7 +122,7 @@ export default class Ros extends EventEmitter<
     this.transport?.close();
   }
 
-  private handleMessage(message: RosbridgeMessage) {
+  private handleMessage(message: RosbridgeMessageBase) {
     if (isRosbridgePublishMessage(message)) {
       this.emit(message.topic, message);
     } else if (isRosbridgeServiceResponseMessage(message)) {
@@ -165,12 +166,12 @@ export default class Ros extends EventEmitter<
     client: string,
     dest: string,
     rand: string,
-    t: object,
+    t: number,
     level: string,
-    end: object,
+    end: number,
   ) {
-    // create the request
-    const auth = {
+    // send the request
+    this.callOnConnection({
       op: "auth",
       mac: mac,
       client: client,
@@ -179,19 +180,14 @@ export default class Ros extends EventEmitter<
       t: t,
       level: level,
       end: end,
-    };
-    // send the request
-    this.callOnConnection(auth);
+    });
   }
 
   /**
    * Sends the message to the transport.
    * If not connected, queues the message to send once reconnected.
    */
-  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters -- to broaden argument type to any RosbridgeMessage variant
-  public callOnConnection<T extends RosbridgeMessage = RosbridgeMessage>(
-    message: T,
-  ) {
+  public callOnConnection(message: RosbridgeMessage) {
     if (this.isConnected()) {
       this.transport?.send(message);
     } else {
@@ -207,7 +203,10 @@ export default class Ros extends EventEmitter<
    * @param level - Status level (none, error, warning, info).
    * @param [id] - Operation ID to change status level on.
    */
-  public setStatusLevel(level: string, id?: string) {
+  public setStatusLevel(
+    level: RosbridgeSetStatusLevelMessage["level"],
+    id?: string,
+  ) {
     const levelMsg: RosbridgeSetStatusLevelMessage = {
       op: "set_level",
       level,

src/core/Service.ts

@@ -4,10 +4,7 @@
  */
 
 import { EventEmitter } from "eventemitter3";
-import type {
-  RosbridgeMessage,
-  RosbridgeServiceResponseMessage,
-} from "../types/protocol.ts";
+import type { RosbridgeMessage } from "../types/protocol.ts";
 import {
   isRosbridgeCallServiceMessage,
   isRosbridgeServiceResponseMessage,
@@ -88,16 +85,13 @@ export default class Service<TRequest, TResponse> extends EventEmitter {
       }
     });
 
-    const call = {
+    this.ros.callOnConnection({
       op: "call_service",
       id: serviceCallId,
       service: this.name,
-      type: this.serviceType,
       args: request,
       timeout: timeout,
-    };
-
-    this.ros.callOnConnection(call);
+    });
   }
   /**
    * Advertise the service. This turns the Service object from a client
@@ -125,7 +119,8 @@ export default class Service<TRequest, TResponse> extends EventEmitter {
               `Invalid message received on service channel: ${JSON.stringify(rosbridgeRequest)}`,
             );
           }
-          const response = {};
+          // @ts-expect-error -- TypeScript doesn't have a way to handle the out-parameter model used here.
+          const response: TResponse = {};
           let success: boolean;
           try {
             success = callback(rosbridgeRequest.args, response);
@@ -140,14 +135,14 @@ export default class Service<TRequest, TResponse> extends EventEmitter {
               values: response,
               result: success,
               id: rosbridgeRequest.id,
-            } satisfies RosbridgeServiceResponseMessage<Partial<TResponse>>);
+            });
           } else {
             this.ros.callOnConnection({
               op: "service_response",
               service: this.name,
               result: success,
               id: rosbridgeRequest.id,
-            } satisfies RosbridgeServiceResponseMessage<Partial<TResponse>>);
+            });
           }
         };
 
@@ -247,15 +242,15 @@ export default class Service<TRequest, TResponse> extends EventEmitter {
                 result: true,
                 values: await callback(rosbridgeRequest.args),
                 id: rosbridgeRequest.id,
-              } satisfies RosbridgeServiceResponseMessage<TResponse>);
+              });
             } catch (err) {
               this.ros.callOnConnection({
                 op: "service_response",
                 service: this.name,
                 result: false,
                 values: String(err),
                 id: rosbridgeRequest.id,
-              } satisfies RosbridgeServiceResponseMessage<TResponse>);
+              });
             }
           })().catch(console.error);
         };

src/core/Topic.ts

@@ -258,14 +258,12 @@ export default class Topic<T> extends EventEmitter<{
       this.advertise();
     }
 
-    const call = {
+    this.ros.callOnConnection({
       op: "publish",
       id: `publish:${this.name}:${uuidv4()}`,
       topic: this.name,
       msg: message,
-      latch: this.latch,
-    };
-    this.ros.callOnConnection(call);
+    });
   }
 
   /**

src/core/transport/Transport.ts

@@ -3,6 +3,7 @@ import type {
   RosbridgePngMessage,
   RosbridgeMessage,
   RosbridgeFragmentMessage,
+  RosbridgeMessageBase,
 } from "../../types/protocol.js";
 import {
   isRosbridgeFragmentMessage,
@@ -60,7 +61,7 @@ export abstract class AbstractTransport
     open: [TransportEvent];
     close: [TransportEvent];
     error: [TransportEvent];
-    message: [RosbridgeMessage];
+    message: [RosbridgeMessageBase];
   }>
   implements ITransport
 {
@@ -114,7 +115,7 @@ export abstract class AbstractTransport
    * If the message is a PNG, it is decompressed and reprocessed.
    * Otherwise, the message is emitted.
    */
-  private handleRosbridgeMessage(message: RosbridgeMessage) {
+  private handleRosbridgeMessage(message: RosbridgeMessageBase) {
     if (isRosbridgeFragmentMessage(message)) {
       this.handleRosbridgeFragmentMessage(message);
     } else if (isRosbridgePngMessage(message)) {