brilliantsole 0.0.27 → 0.0.29

package/src/server/BaseClient.ts

@@ -9,16 +9,36 @@ import {
   ServerMessageType,
 } from "./ServerUtils.ts";
 import { parseMessage, parseStringFromDataView } from "../utils/ParseUtils.ts";
-import EventDispatcher, { BoundEventListeners, Event } from "../utils/EventDispatcher.ts";
+import EventDispatcher, {
+  BoundEventListeners,
+  Event,
+} from "../utils/EventDispatcher.ts";
 import Device from "../Device.ts";
-import { sliceDataView } from "../utils/ArrayBufferUtils.ts";
-import { DiscoveredDevice, DiscoveredDevicesMap, ScannerEventMessages } from "../scanner/BaseScanner.ts";
+import {
+  concatenateArrayBuffers,
+  sliceDataView,
+  stringToArrayBuffer,
+} from "../utils/ArrayBufferUtils.ts";
+import {
+  DiscoveredDevice,
+  DiscoveredDevicesMap,
+  ScannerEventMessages,
+} from "../scanner/BaseScanner.ts";
 import ClientConnectionManager from "../connection/ClientConnectionManager.ts";
 import { DeviceManager } from "../BS.ts";
+import {
+  ClientConnectionType,
+  ConnectionTypes,
+} from "../connection/BaseConnectionManager.ts";
 
 const _console = createConsole("BaseClient", { log: false });
 
-export const ClientConnectionStatuses = ["notConnected", "connecting", "connected", "disconnecting"] as const;
+export const ClientConnectionStatuses = [
+  "notConnected",
+  "connecting",
+  "connected",
+  "disconnecting",
+] as const;
 export type ClientConnectionStatus = (typeof ClientConnectionStatuses)[number];
 
 export const ClientEventTypes = [
@@ -37,11 +57,24 @@ interface ClientConnectionEventMessages {
   isConnected: { isConnected: boolean };
 }
 
-export type ClientEventMessages = ClientConnectionEventMessages & ScannerEventMessages;
-
-export type ClientEventDispatcher = EventDispatcher<BaseClient, ClientEventType, ClientEventMessages>;
-export type ClientEvent = Event<BaseClient, ClientEventType, ClientEventMessages>;
-export type BoundClientEventListeners = BoundEventListeners<BaseClient, ClientEventType, ClientEventMessages>;
+export type ClientEventMessages = ClientConnectionEventMessages &
+  ScannerEventMessages;
+
+export type ClientEventDispatcher = EventDispatcher<
+  BaseClient,
+  ClientEventType,
+  ClientEventMessages
+>;
+export type ClientEvent = Event<
+  BaseClient,
+  ClientEventType,
+  ClientEventMessages
+>;
+export type BoundClientEventListeners = BoundEventListeners<
+  BaseClient,
+  ClientEventType,
+  ClientEventMessages
+>;
 
 export type ServerURL = string | URL;
 
@@ -57,7 +90,8 @@ abstract class BaseClient {
     this.#isScanning = false;
     for (const id in this.#devices) {
       const device = this.#devices[id];
-      const connectionManager = device.connectionManager! as ClientConnectionManager;
+      const connectionManager =
+        device.connectionManager! as ClientConnectionManager;
       connectionManager.isConnected = false;
       //device.removeAllEventListeners();
     }
@@ -71,7 +105,10 @@ abstract class BaseClient {
     return this.#devices;
   }
 
-  #eventDispatcher: ClientEventDispatcher = new EventDispatcher(this as BaseClient, ClientEventTypes);
+  #eventDispatcher: ClientEventDispatcher = new EventDispatcher(
+    this as BaseClient,
+    ClientEventTypes
+  );
   get addEventListener() {
     return this.#eventDispatcher.addEventListener;
   }
@@ -109,7 +146,8 @@ abstract class BaseClient {
     this._reconnectOnDisconnection = newReconnectOnDisconnection;
   }
 
-  protected _reconnectOnDisconnection = this.baseConstructor.ReconnectOnDisconnection;
+  protected _reconnectOnDisconnection =
+    this.baseConstructor.ReconnectOnDisconnection;
   get reconnectOnDisconnection() {
     return this._reconnectOnDisconnection;
   }
@@ -130,7 +168,9 @@ abstract class BaseClient {
     _console.log({ newConnectionStatus });
     this.#_connectionStatus = newConnectionStatus;
 
-    this.dispatchEvent("connectionStatus", { connectionStatus: this.connectionStatus });
+    this.dispatchEvent("connectionStatus", {
+      connectionStatus: this.connectionStatus,
+    });
     this.dispatchEvent(this.connectionStatus, {});
 
     switch (newConnectionStatus) {
@@ -149,7 +189,11 @@ abstract class BaseClient {
     return this._connectionStatus;
   }
 
-  static #RequiredMessageTypes: ServerMessage[] = ["isScanningAvailable", "discoveredDevices", "connectedDevices"];
+  static #RequiredMessageTypes: ServerMessage[] = [
+    "isScanningAvailable",
+    "discoveredDevices",
+    "connectedDevices",
+  ];
   get #requiredMessageTypes(): ServerMessage[] {
     return BaseClient.#RequiredMessageTypes;
   }
@@ -183,7 +227,13 @@ abstract class BaseClient {
 
   protected parseMessage(dataView: DataView) {
     _console.log("parseMessage", { dataView });
-    parseMessage(dataView, ServerMessageTypes, this.#parseMessageCallback.bind(this), null, true);
+    parseMessage(
+      dataView,
+      ServerMessageTypes,
+      this.#parseMessageCallback.bind(this),
+      null,
+      true
+    );
     this.#checkIfFullyConnected();
   }
 
@@ -209,10 +259,15 @@ abstract class BaseClient {
         break;
       case "discoveredDevice":
         {
-          const { string: discoveredDeviceString } = parseStringFromDataView(dataView, byteOffset);
+          const { string: discoveredDeviceString } = parseStringFromDataView(
+            dataView,
+            byteOffset
+          );
           _console.log({ discoveredDeviceString });
 
-          const discoveredDevice: DiscoveredDevice = JSON.parse(discoveredDeviceString);
+          const discoveredDevice: DiscoveredDevice = JSON.parse(
+            discoveredDeviceString
+          );
           _console.log({ discoveredDevice });
 
           this.onDiscoveredDevice(discoveredDevice);
@@ -220,7 +275,10 @@ abstract class BaseClient {
         break;
       case "expiredDiscoveredDevice":
         {
-          const { string: bluetoothId } = parseStringFromDataView(dataView, byteOffset);
+          const { string: bluetoothId } = parseStringFromDataView(
+            dataView,
+            byteOffset
+          );
           this.#onExpiredDiscoveredDevice(bluetoothId);
         }
         break;
@@ -229,20 +287,28 @@ abstract class BaseClient {
           if (dataView.byteLength == 0) {
             break;
           }
-          const { string: connectedBluetoothDeviceIdStrings } = parseStringFromDataView(dataView, byteOffset);
+          const { string: connectedBluetoothDeviceIdStrings } =
+            parseStringFromDataView(dataView, byteOffset);
           _console.log({ connectedBluetoothDeviceIdStrings });
-          const connectedBluetoothDeviceIds = JSON.parse(connectedBluetoothDeviceIdStrings).connectedDevices;
+          const connectedBluetoothDeviceIds = JSON.parse(
+            connectedBluetoothDeviceIdStrings
+          ).connectedDevices;
           _console.log({ connectedBluetoothDeviceIds });
           this.onConnectedBluetoothDeviceIds(connectedBluetoothDeviceIds);
         }
         break;
       case "deviceMessage":
         {
-          const { string: bluetoothId, byteOffset: _byteOffset } = parseStringFromDataView(dataView, byteOffset);
+          const { string: bluetoothId, byteOffset: _byteOffset } =
+            parseStringFromDataView(dataView, byteOffset);
           byteOffset = _byteOffset;
           const device = this.#devices[bluetoothId];
-          _console.assertWithError(device, `no device found for id ${bluetoothId}`);
-          const connectionManager = device.connectionManager! as ClientConnectionManager;
+          _console.assertWithError(
+            device,
+            `no device found for id ${bluetoothId}`
+          );
+          const connectionManager =
+            device.connectionManager! as ClientConnectionManager;
           const _dataView = sliceDataView(dataView, byteOffset);
           connectionManager.onClientMessage(_dataView);
         }
@@ -265,7 +331,9 @@ abstract class BaseClient {
   set #isScanningAvailable(newIsAvailable) {
     _console.assertTypeWithError(newIsAvailable, "boolean");
     this.#_isScanningAvailable = newIsAvailable;
-    this.dispatchEvent("isScanningAvailable", { isScanningAvailable: this.isScanningAvailable });
+    this.dispatchEvent("isScanningAvailable", {
+      isScanningAvailable: this.isScanningAvailable,
+    });
     if (this.isScanningAvailable) {
       this.#requestIsScanning();
     }
@@ -275,7 +343,10 @@ abstract class BaseClient {
   }
   #assertIsScanningAvailable() {
     this.assertConnection();
-    _console.assertWithError(this.isScanningAvailable, "scanning is not available");
+    _console.assertWithError(
+      this.isScanningAvailable,
+      "scanning is not available"
+    );
   }
   protected requestIsScanningAvailable() {
     this.sendServerMessage("isScanningAvailable");
@@ -349,29 +420,61 @@ abstract class BaseClient {
   }
 
   // DEVICE CONNECTION
-  connectToDevice(bluetoothId: string) {
-    return this.requestConnectionToDevice(bluetoothId);
+  connectToDevice(bluetoothId: string, connectionType?: ClientConnectionType) {
+    return this.requestConnectionToDevice(bluetoothId, connectionType);
   }
-  protected requestConnectionToDevice(bluetoothId: string) {
+  protected requestConnectionToDevice(
+    bluetoothId: string,
+    connectionType?: ClientConnectionType
+  ) {
     this.assertConnection();
     _console.assertTypeWithError(bluetoothId, "string");
     const device = this.#getOrCreateDevice(bluetoothId);
-    device.connect();
+    if (connectionType) {
+      device.connect({ type: "client", subType: connectionType });
+    } else {
+      device.connect();
+    }
     return device;
   }
-  protected sendConnectToDeviceMessage(bluetoothId: string) {
-    this.sendServerMessage({ type: "connectToDevice", data: bluetoothId });
+  protected sendConnectToDeviceMessage(
+    bluetoothId: string,
+    connectionType?: ClientConnectionType
+  ) {
+    if (connectionType) {
+      this.sendServerMessage({
+        type: "connectToDevice",
+        data: concatenateArrayBuffers(
+          stringToArrayBuffer(bluetoothId),
+          ConnectionTypes.indexOf(connectionType)
+        ),
+      });
+    } else {
+      this.sendServerMessage({ type: "connectToDevice", data: bluetoothId });
+    }
   }
 
   // DEVICE CONNECTION
   createDevice(bluetoothId: string) {
     const device = new Device();
+    const discoveredDevice = this.#discoveredDevices[bluetoothId];
     const clientConnectionManager = new ClientConnectionManager();
+    clientConnectionManager.discoveredDevice = Object.assign(
+      {},
+      discoveredDevice
+    );
     clientConnectionManager.client = this;
     clientConnectionManager.bluetoothId = bluetoothId;
-    clientConnectionManager.sendClientMessage = this.sendDeviceMessage.bind(this, bluetoothId);
-    clientConnectionManager.sendClientConnectMessage = this.sendConnectToDeviceMessage.bind(this, bluetoothId);
-    clientConnectionManager.sendClientDisconnectMessage = this.sendDisconnectFromDeviceMessage.bind(this, bluetoothId);
+    clientConnectionManager.sendClientMessage = this.sendDeviceMessage.bind(
+      this,
+      bluetoothId
+    );
+    clientConnectionManager.sendRequiredDeviceInformationMessage =
+      this.sendRequiredDeviceInformationMessage.bind(this, bluetoothId);
+    clientConnectionManager.sendClientConnectMessage =
+      this.sendConnectToDeviceMessage.bind(this, bluetoothId);
+    clientConnectionManager.sendClientDisconnectMessage =
+      this.sendDisconnectFromDeviceMessage.bind(this, bluetoothId);
     device.connectionManager = clientConnectionManager;
     return device;
   }
@@ -388,7 +491,8 @@ abstract class BaseClient {
     _console.log({ bluetoothIds });
     bluetoothIds.forEach((bluetoothId) => {
       const device = this.#getOrCreateDevice(bluetoothId);
-      const connectionManager = device.connectionManager! as ClientConnectionManager;
+      const connectionManager =
+        device.connectionManager! as ClientConnectionManager;
       connectionManager.isConnected = true;
       DeviceManager._CheckDeviceAvailability(device);
     });
@@ -409,12 +513,22 @@ abstract class BaseClient {
     this.sendServerMessage({ type: "disconnectFromDevice", data: bluetoothId });
   }
 
-  protected sendDeviceMessage(bluetoothId: string, ...messages: ClientDeviceMessage[]) {
+  protected sendDeviceMessage(
+    bluetoothId: string,
+    ...messages: ClientDeviceMessage[]
+  ) {
     this.sendServerMessage({
       type: "deviceMessage",
       data: [bluetoothId, createClientDeviceMessage(...messages)],
     });
   }
+
+  protected sendRequiredDeviceInformationMessage(bluetoothId: string) {
+    this.sendServerMessage({
+      type: "requiredDeviceInformation",
+      data: [bluetoothId],
+    });
+  }
 }
 
 export default BaseClient;

package/src/server/BaseServer.ts

@@ -16,6 +16,7 @@ import Device, {
   BoundDeviceEventListeners,
   DeviceEventMap,
   DeviceEventType,
+  RequiredInformationConnectionMessages,
 } from "../Device.ts";
 import {
   addEventListeners,
@@ -26,6 +27,8 @@ import { parseMessage, parseStringFromDataView } from "../utils/ParseUtils.ts";
 import {
   ConnectionMessageType,
   ConnectionMessageTypes,
+  ConnectionType,
+  ConnectionTypes,
 } from "../connection/BaseConnectionManager.ts";
 import {
   BoundScannerEventListeners,
@@ -37,6 +40,14 @@ import DeviceManager, {
   DeviceManagerEventMap,
   BoundDeviceManagerEventListeners,
 } from "../DeviceManager.ts";
+import { RequiredWifiMessageTypes } from "../WifiManager.ts";
+import { DeviceInformationTypes } from "../DeviceInformationManager.ts";
+
+const RequiredDeviceInformationMessageTypes: ConnectionMessageType[] = [
+  ...DeviceInformationTypes,
+  "batteryLevel",
+  ...RequiredInformationConnectionMessages,
+];
 
 const _console = createConsole("BaseServer", { log: false });
 
@@ -340,6 +351,9 @@ abstract class BaseServer {
     dataView: DataView,
     context: { responseMessages: ArrayBuffer[] }
   ) {
+    _console.log(
+      `onClientMessage "${messageType}" (${dataView.byteLength} bytes)`
+    );
     const { responseMessages } = context;
     switch (messageType) {
       case "isScanningAvailable":
@@ -359,8 +373,14 @@ abstract class BaseServer {
         break;
       case "connectToDevice":
         {
-          const { string: deviceId } = parseStringFromDataView(dataView);
-          scanner!.connectToDevice(deviceId);
+          const { string: deviceId, byteOffset } =
+            parseStringFromDataView(dataView);
+          let connectionType = undefined;
+          if (byteOffset < dataView.byteLength) {
+            connectionType = ConnectionTypes[dataView.getUint8(byteOffset)];
+            _console.log(`connectToDevice via ${connectionType}`);
+          }
+          scanner!.connectToDevice(deviceId, connectionType);
         }
         break;
       case "disconnectFromDevice":
@@ -403,6 +423,34 @@ abstract class BaseServer {
           }
         }
         break;
+      case "requiredDeviceInformation":
+        {
+          const { string: deviceId } = parseStringFromDataView(dataView);
+          const device = DeviceManager.ConnectedDevices.find(
+            (device) => device.bluetoothId == deviceId
+          );
+          if (!device) {
+            _console.error(`no device found with id ${deviceId}`);
+            break;
+          }
+
+          const messages = RequiredDeviceInformationMessageTypes.map(
+            (messageType) => this.#createDeviceMessage(device, messageType)
+          );
+          if (device.isWifiAvailable) {
+            RequiredWifiMessageTypes.forEach((messageType) => {
+              messages.push(this.#createDeviceMessage(device, messageType));
+            });
+          }
+          const responseMessage = this.#createDeviceServerMessage(
+            device,
+            ...messages
+          );
+          if (responseMessage) {
+            responseMessages.push(responseMessage);
+          }
+        }
+        break;
       default:
         _console.error(`uncaught messageType "${messageType}"`);
         break;

package/src/server/ServerUtils.ts

@@ -1,5 +1,8 @@
 import { DeviceEventTypes } from "../Device.ts";
-import { ConnectionMessageType, ConnectionMessageTypes } from "../connection/BaseConnectionManager.ts";
+import {
+  ConnectionMessageType,
+  ConnectionMessageTypes,
+} from "../connection/BaseConnectionManager.ts";
 import { concatenateArrayBuffers } from "../utils/ArrayBufferUtils.ts";
 import { createConsole } from "../utils/Console.ts";
 import { DeviceEventType } from "../Device.ts";
@@ -18,15 +21,29 @@ export const ServerMessageTypes = [
   "disconnectFromDevice",
   "connectedDevices",
   "deviceMessage",
+  "requiredDeviceInformation",
 ] as const;
 export type ServerMessageType = (typeof ServerMessageTypes)[number];
 
-export const DeviceMessageTypes = ["connectionStatus", "batteryLevel", "deviceInformation", "rx", "smp"] as const;
+export const DeviceMessageTypes = [
+  "connectionStatus",
+  "batteryLevel",
+  "deviceInformation",
+  "rx",
+  "smp",
+] as const;
 export type DeviceMessageType = (typeof DeviceMessageTypes)[number];
 
 // MESSAGING
 
-export type MessageLike = number | number[] | ArrayBufferLike | DataView | boolean | string | any;
+export type MessageLike =
+  | number
+  | number[]
+  | ArrayBufferLike
+  | DataView
+  | boolean
+  | string
+  | any;
 
 export interface Message<MessageType extends string> {
   type: MessageType;
@@ -59,9 +76,17 @@ export function createMessage<MessageType extends string>(
     const messageTypeEnum = enumeration.indexOf(message.type);
 
     const messageDataLengthDataView = new DataView(new ArrayBuffer(2));
-    messageDataLengthDataView.setUint16(0, messageDataArrayBufferByteLength, true);
-
-    return concatenateArrayBuffers(messageTypeEnum, messageDataLengthDataView, messageDataArrayBuffer);
+    messageDataLengthDataView.setUint16(
+      0,
+      messageDataArrayBufferByteLength,
+      true
+    );
+
+    return concatenateArrayBuffers(
+      messageTypeEnum,
+      messageDataLengthDataView,
+      messageDataArrayBuffer
+    );
   });
   _console.log("messageBuffers", ...messageBuffers);
   return concatenateArrayBuffers(...messageBuffers);
@@ -79,15 +104,20 @@ export function createDeviceMessage(...messages: DeviceMessage[]) {
   return createMessage(DeviceEventTypes, ...messages);
 }
 
-export type ClientDeviceMessage = ConnectionMessageType | Message<ConnectionMessageType>;
+export type ClientDeviceMessage =
+  | ConnectionMessageType
+  | Message<ConnectionMessageType>;
 export function createClientDeviceMessage(...messages: ClientDeviceMessage[]) {
   _console.log("createClientDeviceMessage", ...messages);
   return createMessage(ConnectionMessageTypes, ...messages);
 }
 
 // STATIC MESSAGES
-export const isScanningAvailableRequestMessage = createServerMessage("isScanningAvailable");
+export const isScanningAvailableRequestMessage = createServerMessage(
+  "isScanningAvailable"
+);
 export const isScanningRequestMessage = createServerMessage("isScanning");
 export const startScanRequestMessage = createServerMessage("startScan");
 export const stopScanRequestMessage = createServerMessage("stopScan");
-export const discoveredDevicesMessage = createServerMessage("discoveredDevices");
+export const discoveredDevicesMessage =
+  createServerMessage("discoveredDevices");

package/src/server/udp/UDPServer.ts

@@ -1,6 +1,12 @@
-import { concatenateArrayBuffers, dataToArrayBuffer } from "../../utils/ArrayBufferUtils.ts";
+import {
+  concatenateArrayBuffers,
+  dataToArrayBuffer,
+} from "../../utils/ArrayBufferUtils.ts";
 import { createConsole } from "../../utils/Console.ts";
-import { addEventListeners, removeEventListeners } from "../../utils/EventUtils.ts";
+import {
+  addEventListeners,
+  removeEventListeners,
+} from "../../utils/EventUtils.ts";
 import { parseMessage } from "../../utils/ParseUtils.ts";
 import BaseServer from "../BaseServer.ts";
 import {
@@ -11,10 +17,10 @@ import {
   UDPServerMessageType,
   UDPServerMessageTypes,
 } from "./UDPUtils.ts";
+import Timer from "../../utils/Timer.ts";
 
 /** NODE_START */
 import type * as dgram from "dgram";
-import Timer from "../../utils/Timer.ts";
 /** NODE_END */
 
 const _console = createConsole("UDPServer", { log: false });
@@ -38,14 +44,22 @@ class UDPServer extends BaseServer {
     return this.#clients.length;
   }
 
-  #getClientByRemoteInfo(remoteInfo: dgram.RemoteInfo, createIfNotFound = false) {
+  #getClientByRemoteInfo(
+    remoteInfo: dgram.RemoteInfo,
+    createIfNotFound = false
+  ) {
     const { address, port } = remoteInfo;
-    let client = this.#clients.find((client) => client.address == address && client.port == port);
+    let client = this.#clients.find(
+      (client) => client.address == address && client.port == port
+    );
     if (!client && createIfNotFound) {
       client = {
         ...remoteInfo,
         isAlive: true,
-        removeSelfTimer: new Timer(() => this.#removeClient(client!), removeUDPClientTimeout),
+        removeSelfTimer: new Timer(
+          () => this.#removeClient(client!),
+          removeUDPClientTimeout
+        ),
         lastTimeSentData: 0,
       };
       _console.log("created new client", client);
@@ -114,7 +128,11 @@ class UDPServer extends BaseServer {
     _console.log(`socket listening on port ${address.address}:${address.port}`);
   }
   #onSocketMessage(message: Buffer, remoteInfo: dgram.RemoteInfo) {
-    _console.log(`received ${message.length} bytes from ${this.#remoteInfoToString(remoteInfo)}`);
+    _console.log(
+      `received ${message.length} bytes from ${this.#remoteInfoToString(
+        remoteInfo
+      )}`
+    );
     const client = this.#getClientByRemoteInfo(remoteInfo, true);
     if (!client) {
       _console.error("no client found");
@@ -127,7 +145,12 @@ class UDPServer extends BaseServer {
 
   // PARSING
   #onClientData(client: UDPClient, dataView: DataView) {
-    _console.log(`parsing ${dataView.byteLength} bytes from ${this.#clientToString(client)}`, dataView.buffer);
+    _console.log(
+      `parsing ${dataView.byteLength} bytes from ${this.#clientToString(
+        client
+      )}`,
+      dataView.buffer
+    );
     let responseMessages: ArrayBuffer[] = [];
     parseMessage(
       dataView,
@@ -153,9 +176,15 @@ class UDPServer extends BaseServer {
     _console.log(`responding with ${response.byteLength} bytes...`, response);
     this.#sendToClient(client, response);
   }
-  #onClientUDPMessage(messageType: UDPServerMessageType, dataView: DataView, context: UDPClientContext) {
+  #onClientUDPMessage(
+    messageType: UDPServerMessageType,
+    dataView: DataView,
+    context: UDPClientContext
+  ) {
     const { client, responseMessages } = context;
-    _console.log(`received "${messageType}" message from ${client.address}:${client.port}`);
+    _console.log(
+      `received "${messageType}" message from ${client.address}:${client.port}`
+    );
     switch (messageType) {
       case "ping":
         responseMessages.push(this.#createPongMessage(context));
@@ -168,7 +197,12 @@ class UDPServer extends BaseServer {
       case "serverMessage":
         const responseMessage = this.parseClientMessage(dataView);
         if (responseMessage) {
-          responseMessages.push(createUDPServerMessage({ type: "serverMessage", data: responseMessage }));
+          responseMessages.push(
+            createUDPServerMessage({
+              type: "serverMessage",
+              data: responseMessage,
+            })
+          );
         }
         break;
 
@@ -187,24 +221,38 @@ class UDPServer extends BaseServer {
   #parseRemoteReceivePort(dataView: DataView, client: UDPClient) {
     const receivePort = dataView.getUint16(0);
     client.receivePort = receivePort;
-    _console.log(`updated ${client.address}:${client.port} receivePort to ${receivePort}`);
+    _console.log(
+      `updated ${client.address}:${client.port} receivePort to ${receivePort}`
+    );
     const responseDataView = new DataView(new ArrayBuffer(2));
     responseDataView.setUint16(0, client.receivePort);
-    return createUDPServerMessage({ type: "setRemoteReceivePort", data: responseDataView });
+    return createUDPServerMessage({
+      type: "setRemoteReceivePort",
+      data: responseDataView,
+    });
   }
 
   // CLIENT MESSAGING
   #sendToClient(client: UDPClient, message: ArrayBuffer) {
-    _console.log(`sending ${message.byteLength} bytes to ${this.#clientToString(client)}...`);
+    _console.log(
+      `sending ${message.byteLength} bytes to ${this.#clientToString(
+        client
+      )}...`
+    );
     try {
-      this.#socket!.send(new Uint8Array(message), client.receivePort, client.address, (error, bytes) => {
-        if (error) {
-          _console.error("error sending data", error);
-          return;
+      this.#socket!.send(
+        new Uint8Array(message),
+        client.receivePort,
+        client.address,
+        (error, bytes) => {
+          if (error) {
+            _console.error("error sending data", error);
+            return;
+          }
+          _console.log(`sent ${bytes} bytes`);
+          client.lastTimeSentData = Date.now();
         }
-        _console.log(`sent ${bytes} bytes`);
-        client.lastTimeSentData = Date.now();
-      });
+      );
     } catch (error) {
       _console.error("serious error sending data", error);
     }
@@ -212,7 +260,10 @@ class UDPServer extends BaseServer {
   broadcastMessage(message: ArrayBuffer) {
     super.broadcastMessage(message);
     this.#clients.forEach((client) => {
-      this.#sendToClient(client, createUDPServerMessage({ type: "serverMessage", data: message }));
+      this.#sendToClient(
+        client,
+        createUDPServerMessage({ type: "serverMessage", data: message })
+      );
     });
   }