brilliantsole 0.0.26 → 0.0.28

package/src/server/BaseServer.ts

@@ -1,5 +1,9 @@
 import { createConsole } from "../utils/Console.ts";
-import EventDispatcher, { BoundEventListeners, Event, EventMap } from "../utils/EventDispatcher.ts";
+import EventDispatcher, {
+  BoundEventListeners,
+  Event,
+  EventMap,
+} from "../utils/EventDispatcher.ts";
 import {
   createServerMessage,
   ServerMessageTypes,
@@ -8,18 +12,49 @@ import {
   ServerMessageType,
   createDeviceMessage,
 } from "./ServerUtils.ts";
-import Device, { BoundDeviceEventListeners, DeviceEventMap, DeviceEventType } from "../Device.ts";
-import { addEventListeners, removeEventListeners } from "../utils/EventUtils.ts";
+import Device, {
+  BoundDeviceEventListeners,
+  DeviceEventMap,
+  DeviceEventType,
+  RequiredInformationConnectionMessages,
+} from "../Device.ts";
+import {
+  addEventListeners,
+  removeEventListeners,
+} from "../utils/EventUtils.ts";
 import scanner from "../scanner/Scanner.ts";
 import { parseMessage, parseStringFromDataView } from "../utils/ParseUtils.ts";
-import { ConnectionMessageType, ConnectionMessageTypes } from "../connection/BaseConnectionManager.ts";
-import { BoundScannerEventListeners, DiscoveredDevice, ScannerEventMap } from "../scanner/BaseScanner.ts";
+import {
+  ConnectionMessageType,
+  ConnectionMessageTypes,
+  ConnectionType,
+  ConnectionTypes,
+} from "../connection/BaseConnectionManager.ts";
+import {
+  BoundScannerEventListeners,
+  DiscoveredDevice,
+  ScannerEventMap,
+} from "../scanner/BaseScanner.ts";
 import { concatenateArrayBuffers } from "../utils/ArrayBufferUtils.ts";
-import DeviceManager, { DeviceManagerEventMap, BoundDeviceManagerEventListeners } from "../DeviceManager.ts";
-
-const _console = createConsole("BaseServer", { log: true });
-
-export const ServerEventTypes = ["clientConnected", "clientDisconnected"] as const;
+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 });
+
+export const ServerEventTypes = [
+  "clientConnected",
+  "clientDisconnected",
+] as const;
 export type ServerEventType = (typeof ServerEventTypes)[number];
 
 interface ServerEventMessages {
@@ -27,14 +62,33 @@ interface ServerEventMessages {
   clientDisconnected: { client: any };
 }
 
-export type ServerEventDispatcher = EventDispatcher<BaseServer, ServerEventType, ServerEventMessages>;
-export type ServerEvent = Event<BaseServer, ServerEventType, ServerEventMessages>;
-export type ServerEventMap = EventMap<BaseServer, ServerEventType, ServerEventMessages>;
-export type BoundServerEventListeners = BoundEventListeners<BaseServer, ServerEventType, ServerEventMessages>;
+export type ServerEventDispatcher = EventDispatcher<
+  BaseServer,
+  ServerEventType,
+  ServerEventMessages
+>;
+export type ServerEvent = Event<
+  BaseServer,
+  ServerEventType,
+  ServerEventMessages
+>;
+export type ServerEventMap = EventMap<
+  BaseServer,
+  ServerEventType,
+  ServerEventMessages
+>;
+export type BoundServerEventListeners = BoundEventListeners<
+  BaseServer,
+  ServerEventType,
+  ServerEventMessages
+>;
 
 abstract class BaseServer {
   // EVENT DISPATCHER
-  protected eventDispatcher: ServerEventDispatcher = new EventDispatcher(this as BaseServer, ServerEventTypes);
+  protected eventDispatcher: ServerEventDispatcher = new EventDispatcher(
+    this as BaseServer,
+    ServerEventTypes
+  );
   get addEventListener() {
     return this.eventDispatcher.addEventListener;
   }
@@ -71,7 +125,8 @@ abstract class BaseServer {
     this.#ClearSensorConfigurationsWhenNoClients = newValue;
   }
 
-  #clearSensorConfigurationsWhenNoClients = BaseServer.#ClearSensorConfigurationsWhenNoClients;
+  #clearSensorConfigurationsWhenNoClients =
+    BaseServer.#ClearSensorConfigurationsWhenNoClients;
   get clearSensorConfigurationsWhenNoClients() {
     return this.#clearSensorConfigurationsWhenNoClients;
   }
@@ -92,7 +147,10 @@ abstract class BaseServer {
   #onClientDisconnected(event: ServerEventMap["clientDisconnected"]) {
     const client = event.message.client;
     _console.log("onClientDisconnected");
-    if (this.numberOfClients == 0 && this.clearSensorConfigurationsWhenNoClients) {
+    if (
+      this.numberOfClients == 0 &&
+      this.clearSensorConfigurationsWhenNoClients
+    ) {
       DeviceManager.ConnectedDevices.forEach((device) => {
         device.clearSensorConfiguration();
         device.setTfliteInferencingEnabled(false);
@@ -117,33 +175,51 @@ abstract class BaseServer {
     this.broadcastMessage(this.#isScanningAvailableMessage);
   }
   get #isScanningAvailableMessage() {
-    return createServerMessage({ type: "isScanningAvailable", data: scanner!.isScanningAvailable });
+    return createServerMessage({
+      type: "isScanningAvailable",
+      data: scanner!.isScanningAvailable,
+    });
   }
 
   #onScannerIsScanning(event: ScannerEventMap["isScanning"]) {
     this.broadcastMessage(this.#isScanningMessage);
   }
   get #isScanningMessage() {
-    return createServerMessage({ type: "isScanning", data: scanner!.isScanning });
+    return createServerMessage({
+      type: "isScanning",
+      data: scanner!.isScanning,
+    });
   }
 
   #onScannerDiscoveredDevice(event: ScannerEventMap["discoveredDevice"]) {
     const { discoveredDevice } = event.message;
     _console.log(discoveredDevice);
 
-    this.broadcastMessage(this.#createDiscoveredDeviceMessage(discoveredDevice));
+    this.broadcastMessage(
+      this.#createDiscoveredDeviceMessage(discoveredDevice)
+    );
   }
   #createDiscoveredDeviceMessage(discoveredDevice: DiscoveredDevice) {
-    return createServerMessage({ type: "discoveredDevice", data: discoveredDevice });
+    return createServerMessage({
+      type: "discoveredDevice",
+      data: discoveredDevice,
+    });
   }
 
-  #onExpiredDiscoveredDevice(event: ScannerEventMap["expiredDiscoveredDevice"]) {
+  #onExpiredDiscoveredDevice(
+    event: ScannerEventMap["expiredDiscoveredDevice"]
+  ) {
     const { discoveredDevice } = event.message;
     _console.log("expired", discoveredDevice);
-    this.broadcastMessage(this.#createExpiredDiscoveredDeviceMessage(discoveredDevice));
+    this.broadcastMessage(
+      this.#createExpiredDiscoveredDeviceMessage(discoveredDevice)
+    );
   }
   #createExpiredDiscoveredDeviceMessage(discoveredDevice: DiscoveredDevice) {
-    return createServerMessage({ type: "expiredDiscoveredDevice", data: discoveredDevice.bluetoothId });
+    return createServerMessage({
+      type: "expiredDiscoveredDevice",
+      data: discoveredDevice.bluetoothId,
+    });
   }
 
   get #discoveredDevicesMessage() {
@@ -163,7 +239,11 @@ abstract class BaseServer {
   get #connectedDevicesMessage() {
     return createServerMessage({
       type: "connectedDevices",
-      data: JSON.stringify({ connectedDevices: DeviceManager.ConnectedDevices.map((device) => device.bluetoothId) }),
+      data: JSON.stringify({
+        connectedDevices: DeviceManager.ConnectedDevices.map(
+          (device) => device.bluetoothId
+        ),
+      }),
     });
   }
 
@@ -173,10 +253,14 @@ abstract class BaseServer {
     connectionMessage: this.#onDeviceConnectionMessage.bind(this),
   };
 
-  #createDeviceMessage(device: Device, messageType: ConnectionMessageType, dataView?: DataView): DeviceMessage {
+  #createDeviceMessage(
+    device: Device,
+    messageType: ConnectionMessageType,
+    dataView?: DataView
+  ): DeviceMessage {
     return {
       type: messageType as DeviceEventType,
-      data: dataView || device.latestConnectionMessage.get(messageType),
+      data: dataView || device.latestConnectionMessages.get(messageType),
     };
   }
 
@@ -191,7 +275,10 @@ abstract class BaseServer {
     const { messageType, dataView } = message;
 
     this.broadcastMessage(
-      this.#createDeviceServerMessage(device, this.#createDeviceMessage(device, messageType, dataView))
+      this.#createDeviceServerMessage(
+        device,
+        this.#createDeviceMessage(device, messageType, dataView)
+      )
     );
   }
 
@@ -202,26 +289,35 @@ abstract class BaseServer {
     deviceIsConnected: this.#onDeviceIsConnected.bind(this),
   };
 
-  #onDeviceConnected(staticDeviceEvent: DeviceManagerEventMap["deviceConnected"]) {
+  #onDeviceConnected(
+    staticDeviceEvent: DeviceManagerEventMap["deviceConnected"]
+  ) {
     const { device } = staticDeviceEvent.message;
     _console.log("onDeviceConnected", device.bluetoothId);
     addEventListeners(device, this.#boundDeviceListeners);
     device.isServerSide = true;
   }
 
-  #onDeviceDisconnected(staticDeviceEvent: DeviceManagerEventMap["deviceDisconnected"]) {
+  #onDeviceDisconnected(
+    staticDeviceEvent: DeviceManagerEventMap["deviceDisconnected"]
+  ) {
     const { device } = staticDeviceEvent.message;
     _console.log("onDeviceDisconnected", device.bluetoothId);
     removeEventListeners(device, this.#boundDeviceListeners);
   }
 
-  #onDeviceIsConnected(staticDeviceEvent: DeviceManagerEventMap["deviceIsConnected"]) {
+  #onDeviceIsConnected(
+    staticDeviceEvent: DeviceManagerEventMap["deviceIsConnected"]
+  ) {
     const { device } = staticDeviceEvent.message;
     _console.log("onDeviceIsConnected", device.bluetoothId);
     this.broadcastMessage(this.#createDeviceIsConnectedMessage(device));
   }
   #createDeviceIsConnectedMessage(device: Device) {
-    return this.#createDeviceServerMessage(device, { type: "isConnected", data: device.isConnected });
+    return this.#createDeviceServerMessage(device, {
+      type: "isConnected",
+      data: device.isConnected,
+    });
   }
 
   #createDeviceServerMessage(device: Device, ...messages: DeviceMessage[]) {
@@ -235,7 +331,13 @@ abstract class BaseServer {
   protected parseClientMessage(dataView: DataView) {
     let responseMessages: ArrayBuffer[] = [];
 
-    parseMessage(dataView, ServerMessageTypes, this.#onClientMessage.bind(this), { responseMessages }, true);
+    parseMessage(
+      dataView,
+      ServerMessageTypes,
+      this.#onClientMessage.bind(this),
+      { responseMessages },
+      true
+    );
 
     responseMessages = responseMessages.filter(Boolean);
 
@@ -244,7 +346,14 @@ abstract class BaseServer {
     }
   }
 
-  #onClientMessage(messageType: ServerMessageType, dataView: DataView, context: { responseMessages: ArrayBuffer[] }) {
+  #onClientMessage(
+    messageType: ServerMessageType,
+    dataView: DataView,
+    context: { responseMessages: ArrayBuffer[] }
+  ) {
+    _console.log(
+      `onClientMessage "${messageType}" (${dataView.byteLength} bytes)`
+    );
     const { responseMessages } = context;
     switch (messageType) {
       case "isScanningAvailable":
@@ -264,14 +373,22 @@ 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":
         {
           const { string: deviceId } = parseStringFromDataView(dataView);
-          const device = DeviceManager.ConnectedDevices.find((device) => device.bluetoothId == deviceId);
+          const device = DeviceManager.ConnectedDevices.find(
+            (device) => device.bluetoothId == deviceId
+          );
           if (!device) {
             _console.error(`no device found with id ${deviceId}`);
             break;
@@ -284,14 +401,51 @@ abstract class BaseServer {
         break;
       case "deviceMessage":
         {
-          const { string: deviceId, byteOffset } = parseStringFromDataView(dataView);
-          const device = DeviceManager.ConnectedDevices.find((device) => device.bluetoothId == deviceId);
+          const { string: deviceId, byteOffset } =
+            parseStringFromDataView(dataView);
+          const device = DeviceManager.ConnectedDevices.find(
+            (device) => device.bluetoothId == deviceId
+          );
           if (!device) {
             _console.error(`no device found with id ${deviceId}`);
             break;
           }
-          const _dataView = new DataView(dataView.buffer, dataView.byteOffset + byteOffset);
-          const responseMessage = this.parseClientDeviceMessage(device, _dataView);
+          const _dataView = new DataView(
+            dataView.buffer,
+            dataView.byteOffset + byteOffset
+          );
+          const responseMessage = this.parseClientDeviceMessage(
+            device,
+            _dataView
+          );
+          if (responseMessage) {
+            responseMessages.push(responseMessage);
+          }
+        }
+        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);
           }
@@ -326,7 +480,9 @@ abstract class BaseServer {
     dataView: DataView,
     context: { responseMessages: DeviceMessage[]; device: Device }
   ) {
-    _console.log(`clientDeviceMessage ${messageType} (${dataView.byteLength} bytes)`);
+    _console.log(
+      `clientDeviceMessage ${messageType} (${dataView.byteLength} bytes)`
+    );
     switch (messageType) {
       case "smp":
         context.device.connectionManager!.sendSmpMessage(dataView.buffer);
@@ -335,7 +491,9 @@ abstract class BaseServer {
         context.device.connectionManager!.sendTxData(dataView.buffer);
         break;
       default:
-        context.responseMessages.push(this.#createDeviceMessage(context.device, messageType));
+        context.responseMessages.push(
+          this.#createDeviceMessage(context.device, 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,13 +17,13 @@ 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: true });
+const _console = createConsole("UDPServer", { log: false });
 
 interface UDPClient extends dgram.RemoteInfo {
   receivePort?: number;
@@ -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 })
+      );
     });
   }
 

package/src/server/udp/UDPUtils.ts

@@ -6,10 +6,17 @@ const _console = createConsole("UDPUtils", { log: false });
 export const pongUDPClientTimeout = 2_000;
 export const removeUDPClientTimeout = 3_000;
 
-export const UDPServerMessageTypes = ["ping", "pong", "setRemoteReceivePort", "serverMessage"] as const;
+export const UDPServerMessageTypes = [
+  "ping",
+  "pong",
+  "setRemoteReceivePort",
+  "serverMessage",
+] as const;
 export type UDPServerMessageType = (typeof UDPServerMessageTypes)[number];
 
-export type UDPServerMessage = UDPServerMessageType | Message<UDPServerMessageType>;
+export type UDPServerMessage =
+  | UDPServerMessageType
+  | Message<UDPServerMessageType>;
 export function createUDPServerMessage(...messages: UDPServerMessage[]) {
   _console.log("createUDPServerMessage", ...messages);
   return createMessage(UDPServerMessageTypes, ...messages);