@foxglove/ros1/src/TcpTypes.ts

Standalone TypeScript implementation of the ROS 1 (Robot Operating System) protocol with a pluggable transport layer

export type TcpAddress = {
  port: number;
  family?: string;
  address: string;
};

export interface NetworkInterface {
  name: string;
  family: "IPv4" | "IPv6";
  internal: boolean;
  address: string;
  cidr?: string;
  mac: string;
  netmask: string;
}

export interface TcpSocketEvents {
  connect: () => void;
  close: () => void;
  data: (data: Uint8Array) => void;
  end: () => void;
  timeout: () => void;
  error: (err: Error) => void;
}

export interface TcpSocket {
  remoteAddress(): Promise<TcpAddress | undefined>;
  localAddress(): Promise<TcpAddress | undefined>;
  fd(): Promise<number | undefined>;
  connected(): Promise<boolean>;

  connect(): Promise<void>;
  close(): Promise<void>;
  write(data: Uint8Array): Promise<void>;
  setNoDelay(noDelay?: boolean): Promise<void>;

  on(eventName: "connect", listener: () => void): this;
  on(eventName: "close", listener: () => void): this;
  on(eventName: "data", listener: (data: Uint8Array) => void): this;
  on(eventName: "end", listener: () => void): this;
  on(eventName: "timeout", listener: () => void): this;
  on(eventName: "error", listener: (err: Error) => void): this;
}

export interface TcpServerEvents {
  close: () => void;
  connection: (socket: TcpSocket) => void;
  error: (err: Error) => void;
}

export interface TcpServer {
  address(): Promise<TcpAddress | undefined>;
  close(): void;

  on(eventName: "close", listener: () => void): this;
  on(eventName: "connection", listener: (socket: TcpSocket) => void): this;
  on(eventName: "error", listener: (err: Error) => void): this;
}

export interface TcpListen {
  (options: { host?: string; port?: number; backlog?: number }): Promise<TcpServer>;
}

export interface TcpSocketCreate {
  (options: { host: string; port: number }): Promise<TcpSocket>;
}