brilliantsole 0.0.27 → 0.0.29

package/src/connection/bluetooth/NobleConnectionManager.ts

@@ -1,7 +1,11 @@
 import { dataToArrayBuffer } from "../../utils/ArrayBufferUtils.ts";
 import { createConsole } from "../../utils/Console.ts";
 import { isInNode } from "../../utils/environment.ts";
-import { addEventListeners, removeEventListeners, BoundGenericEventListeners } from "../../utils/EventUtils.ts";
+import {
+  addEventListeners,
+  removeEventListeners,
+  BoundGenericEventListeners,
+} from "../../utils/EventUtils.ts";
 import {
   allServiceUUIDs,
   getServiceNameFromUUID,
@@ -17,20 +21,27 @@ const _console = createConsole("NobleConnectionManager", { log: false });
 import type * as noble from "@abandonware/noble";
 /** NODE_END */
 
-import { BluetoothCharacteristicName, BluetoothServiceName } from "./bluetoothUUIDs.ts";
+import {
+  BluetoothCharacteristicName,
+  BluetoothServiceName,
+} from "./bluetoothUUIDs.ts";
 import { ConnectionType } from "../BaseConnectionManager.ts";
 import NobleScanner from "../../scanner/NobleScanner.ts";
 
 interface HasConnectionManager {
   connectionManager: NobleConnectionManager | undefined;
 }
-export interface NoblePeripheral extends noble.Peripheral, HasConnectionManager {
+export interface NoblePeripheral
+  extends noble.Peripheral,
+    HasConnectionManager {
   scanner: NobleScanner;
 }
 interface NobleService extends noble.Service, HasConnectionManager {
   name: BluetoothServiceName;
 }
-interface NobleCharacteristic extends noble.Characteristic, HasConnectionManager {
+interface NobleCharacteristic
+  extends noble.Characteristic,
+    HasConnectionManager {
   name: BluetoothCharacteristicName;
 }
 
@@ -63,16 +74,27 @@ class NobleConnectionManager extends BluetoothConnectionManager {
     await this.#noblePeripheral!.disconnectAsync();
   }
 
-  async writeCharacteristic(characteristicName: BluetoothCharacteristicName, data: ArrayBuffer) {
+  async writeCharacteristic(
+    characteristicName: BluetoothCharacteristicName,
+    data: ArrayBuffer
+  ) {
     const characteristic = this.#characteristics.get(characteristicName)!;
-    _console.assertWithError(characteristic, `no characteristic found with name "${characteristicName}"`);
+    _console.assertWithError(
+      characteristic,
+      `no characteristic found with name "${characteristicName}"`
+    );
     // if (data instanceof DataView) {
     //     data = data.buffer;
     // }
     const properties = getCharacteristicProperties(characteristicName);
     const buffer = Buffer.from(data);
     const writeWithoutResponse = properties.writeWithoutResponse;
-    _console.log(`writing to ${characteristicName} ${writeWithoutResponse ? "without" : "with"} response`, buffer);
+    _console.log(
+      `writing to ${characteristicName} ${
+        writeWithoutResponse ? "without" : "with"
+      } response`,
+      buffer
+    );
     await characteristic.writeAsync(buffer, writeWithoutResponse);
     if (characteristic.properties.includes("read")) {
       await characteristic.readAsync();
@@ -84,32 +106,39 @@ class NobleConnectionManager extends BluetoothConnectionManager {
   }
   async reconnect() {
     await super.reconnect();
-    _console.log("attempting to reconnect...");
-    this.connect();
+    await this.#noblePeripheral!.connectAsync();
   }
 
   // NOBLE
-  #noblePeripheral!: NoblePeripheral | undefined;
-  get noblePeripheral(): NoblePeripheral | undefined {
+  #noblePeripheral?: NoblePeripheral;
+  get noblePeripheral() {
     return this.#noblePeripheral;
   }
-  set noblePeripheral(newNoblePeripheral: NoblePeripheral) {
-    _console.assertTypeWithError(newNoblePeripheral, "object");
+  set noblePeripheral(newNoblePeripheral) {
+    if (newNoblePeripheral) {
+      _console.assertTypeWithError(newNoblePeripheral, "object");
+    }
     if (this.noblePeripheral == newNoblePeripheral) {
       _console.log("attempted to assign duplicate noblePeripheral");
       return;
     }
 
-    _console.log("newNoblePeripheral", newNoblePeripheral.id);
+    _console.log("newNoblePeripheral", newNoblePeripheral?.id);
 
     if (this.#noblePeripheral) {
-      removeEventListeners(this.#noblePeripheral, this.#unboundNoblePeripheralListeners);
+      removeEventListeners(
+        this.#noblePeripheral,
+        this.#unboundNoblePeripheralListeners
+      );
       delete this.#noblePeripheral!.connectionManager;
     }
 
     if (newNoblePeripheral) {
       newNoblePeripheral.connectionManager = this;
-      addEventListeners(newNoblePeripheral, this.#unboundNoblePeripheralListeners);
+      addEventListeners(
+        newNoblePeripheral,
+        this.#unboundNoblePeripheralListeners
+      );
     }
 
     this.#noblePeripheral = newNoblePeripheral;
@@ -127,9 +156,15 @@ class NobleConnectionManager extends BluetoothConnectionManager {
     await this.connectionManager!.onNoblePeripheralConnect(this);
   }
   async onNoblePeripheralConnect(noblePeripheral: NoblePeripheral) {
-    _console.log("onNoblePeripheralConnect", noblePeripheral.id, noblePeripheral.state);
+    _console.log(
+      "onNoblePeripheralConnect",
+      noblePeripheral.id,
+      noblePeripheral.state
+    );
     if (noblePeripheral.state == "connected") {
-      await this.#noblePeripheral!.discoverServicesAsync(allServiceUUIDs as string[]);
+      await this.#noblePeripheral!.discoverServicesAsync(
+        allServiceUUIDs as string[]
+      );
     }
     // this gets called when it connects and disconnects, so we use the noblePeripheral's "state" property instead
     await this.#onNoblePeripheralState();
@@ -144,7 +179,11 @@ class NobleConnectionManager extends BluetoothConnectionManager {
   }
 
   async #onNoblePeripheralState() {
-    _console.log(`noblePeripheral ${this.bluetoothId} state ${this.#noblePeripheral!.state}`);
+    _console.log(
+      `noblePeripheral ${this.bluetoothId} state ${
+        this.#noblePeripheral!.state
+      }`
+    );
 
     switch (this.#noblePeripheral!.state) {
       case "connected":
@@ -164,7 +203,9 @@ class NobleConnectionManager extends BluetoothConnectionManager {
         _console.error("noblePeripheral error");
         break;
       default:
-        _console.log(`uncaught noblePeripheral state ${this.#noblePeripheral!.state}`);
+        _console.log(
+          `uncaught noblePeripheral state ${this.#noblePeripheral!.state}`
+        );
         break;
     }
   }
@@ -180,7 +221,10 @@ class NobleConnectionManager extends BluetoothConnectionManager {
       _console.log(
         `removing listeners from characteristic "${characteristic.name}" has ${characteristic.listeners.length} listeners`
       );
-      removeEventListeners(characteristic, this.#unboundNobleCharacteristicListeners);
+      removeEventListeners(
+        characteristic,
+        this.#unboundNobleCharacteristicListeners
+      );
     });
     this.#characteristics.clear();
   }
@@ -188,15 +232,27 @@ class NobleConnectionManager extends BluetoothConnectionManager {
   async #onNoblePeripheralRssiUpdate(this: NoblePeripheral, rssi: number) {
     await this.connectionManager!.onNoblePeripheralRssiUpdate(this, rssi);
   }
-  async onNoblePeripheralRssiUpdate(noblePeripheral: NoblePeripheral, rssi: number) {
+  async onNoblePeripheralRssiUpdate(
+    noblePeripheral: NoblePeripheral,
+    rssi: number
+  ) {
     _console.log("onNoblePeripheralRssiUpdate", noblePeripheral.id, rssi);
-    // FILL
+    // TODO: - can this be useful?
   }
 
-  async #onNoblePeripheralServicesDiscover(this: NoblePeripheral, services: NobleService[]) {
-    await this.connectionManager!.onNoblePeripheralServicesDiscover(this, services);
+  async #onNoblePeripheralServicesDiscover(
+    this: NoblePeripheral,
+    services: NobleService[]
+  ) {
+    await this.connectionManager!.onNoblePeripheralServicesDiscover(
+      this,
+      services
+    );
   }
-  async onNoblePeripheralServicesDiscover(noblePeripheral: NoblePeripheral, services: NobleService[]) {
+  async onNoblePeripheralServicesDiscover(
+    noblePeripheral: NoblePeripheral,
+    services: NobleService[]
+  ) {
     _console.log(
       "onNoblePeripheralServicesDiscover",
       noblePeripheral.id,
@@ -206,7 +262,10 @@ class NobleConnectionManager extends BluetoothConnectionManager {
       const service = services[index];
       _console.log("service", service.uuid);
       const serviceName = getServiceNameFromUUID(service.uuid)!;
-      _console.assertWithError(serviceName, `no name found for service uuid "${service.uuid}"`);
+      _console.assertWithError(
+        serviceName,
+        `no name found for service uuid "${service.uuid}"`
+      );
       _console.log({ serviceName });
       this.#services.set(serviceName, service);
       service.name = serviceName;
@@ -223,10 +282,19 @@ class NobleConnectionManager extends BluetoothConnectionManager {
     characteristicsDiscover: this.#onNobleServiceCharacteristicsDiscover,
   };
 
-  async #onNobleServiceCharacteristicsDiscover(this: NobleService, characteristics: NobleCharacteristic[]) {
-    await this.connectionManager!.onNobleServiceCharacteristicsDiscover(this, characteristics);
+  async #onNobleServiceCharacteristicsDiscover(
+    this: NobleService,
+    characteristics: NobleCharacteristic[]
+  ) {
+    await this.connectionManager!.onNobleServiceCharacteristicsDiscover(
+      this,
+      characteristics
+    );
   }
-  async onNobleServiceCharacteristicsDiscover(service: NobleService, characteristics: NobleCharacteristic[]) {
+  async onNobleServiceCharacteristicsDiscover(
+    service: NobleService,
+    characteristics: NobleCharacteristic[]
+  ) {
     _console.log(
       "onNobleServiceCharacteristicsDiscover",
       service.uuid,
@@ -236,7 +304,9 @@ class NobleConnectionManager extends BluetoothConnectionManager {
     for (const index in characteristics) {
       const characteristic = characteristics[index];
       _console.log("characteristic", characteristic.uuid);
-      const characteristicName = getCharacteristicNameFromUUID(characteristic.uuid)!;
+      const characteristicName = getCharacteristicNameFromUUID(
+        characteristic.uuid
+      )!;
       _console.assertWithError(
         Boolean(characteristicName),
         `no name found for characteristic uuid "${characteristic.uuid}"`
@@ -248,7 +318,10 @@ class NobleConnectionManager extends BluetoothConnectionManager {
       _console.log(
         `adding listeners to characteristic "${characteristic.name}" (currently has ${characteristic.listeners.length} listeners)`
       );
-      addEventListeners(characteristic, this.#unboundNobleCharacteristicListeners);
+      addEventListeners(
+        characteristic,
+        this.#unboundNobleCharacteristicListeners
+      );
       if (characteristic.properties.includes("read")) {
         await characteristic.readAsync();
       }
@@ -269,7 +342,8 @@ class NobleConnectionManager extends BluetoothConnectionManager {
     notify: this.#onNobleCharacteristicNotify,
   };
 
-  #characteristics: Map<BluetoothCharacteristicName, NobleCharacteristic> = new Map();
+  #characteristics: Map<BluetoothCharacteristicName, NobleCharacteristic> =
+    new Map();
 
   get #hasAllCharacteristics() {
     return allCharacteristicNames.every((characteristicName) => {
@@ -280,11 +354,28 @@ class NobleConnectionManager extends BluetoothConnectionManager {
     });
   }
 
-  #onNobleCharacteristicData(this: NobleCharacteristic, data: Buffer, isNotification: boolean) {
-    this.connectionManager!.onNobleCharacteristicData(this, data, isNotification);
+  #onNobleCharacteristicData(
+    this: NobleCharacteristic,
+    data: Buffer,
+    isNotification: boolean
+  ) {
+    this.connectionManager!.onNobleCharacteristicData(
+      this,
+      data,
+      isNotification
+    );
   }
-  onNobleCharacteristicData(characteristic: NobleCharacteristic, data: Buffer, isNotification: boolean) {
-    _console.log("onNobleCharacteristicData", characteristic.uuid, data, isNotification);
+  onNobleCharacteristicData(
+    characteristic: NobleCharacteristic,
+    data: Buffer,
+    isNotification: boolean
+  ) {
+    _console.log(
+      "onNobleCharacteristicData",
+      characteristic.uuid,
+      data,
+      isNotification
+    );
     const dataView = new DataView(dataToArrayBuffer(data));
 
     const characteristicName: BluetoothCharacteristicName = characteristic.name;
@@ -301,14 +392,29 @@ class NobleConnectionManager extends BluetoothConnectionManager {
   }
   onNobleCharacteristicWrite(characteristic: NobleCharacteristic) {
     _console.log("onNobleCharacteristicWrite", characteristic.uuid);
-    // FILL
+    // TODO: - can this be useful?
   }
 
-  #onNobleCharacteristicNotify(this: NobleCharacteristic, isSubscribed: boolean) {
+  #onNobleCharacteristicNotify(
+    this: NobleCharacteristic,
+    isSubscribed: boolean
+  ) {
     this.connectionManager!.onNobleCharacteristicNotify(this, isSubscribed);
   }
-  onNobleCharacteristicNotify(characteristic: NobleCharacteristic, isSubscribed: boolean) {
-    _console.log("onNobleCharacteristicNotify", characteristic.uuid, isSubscribed);
+  onNobleCharacteristicNotify(
+    characteristic: NobleCharacteristic,
+    isSubscribed: boolean
+  ) {
+    _console.log(
+      "onNobleCharacteristicNotify",
+      characteristic.uuid,
+      isSubscribed
+    );
+  }
+
+  remove() {
+    super.remove();
+    this.noblePeripheral = undefined;
   }
 }
 

package/src/connection/bluetooth/WebBluetoothConnectionManager.ts

@@ -1,6 +1,14 @@
 import { createConsole } from "../../utils/Console.ts";
-import { isInNode, isInBrowser, isInBluefy, isInWebBLE } from "../../utils/environment.ts";
-import { addEventListeners, removeEventListeners } from "../../utils/EventUtils.ts";
+import {
+  isInNode,
+  isInBrowser,
+  isInBluefy,
+  isInWebBLE,
+} from "../../utils/environment.ts";
+import {
+  addEventListeners,
+  removeEventListeners,
+} from "../../utils/EventUtils.ts";
 import {
   serviceUUIDs,
   optionalServiceUUIDs,
@@ -9,7 +17,10 @@ import {
   getCharacteristicProperties,
 } from "./bluetoothUUIDs.ts";
 import BluetoothConnectionManager from "./BluetoothConnectionManager.ts";
-import { BluetoothCharacteristicName, BluetoothServiceName } from "./bluetoothUUIDs.ts";
+import {
+  BluetoothCharacteristicName,
+  BluetoothServiceName,
+} from "./bluetoothUUIDs.ts";
 import { ConnectionType } from "../BaseConnectionManager.ts";
 
 const _console = createConsole("WebBluetoothConnectionManager", { log: false });
@@ -46,12 +57,15 @@ class WebBluetoothConnectionManager extends BluetoothConnectionManager {
     return this.#characteristics.has("smp");
   }
 
-  #boundBluetoothCharacteristicEventListeners: { [eventType: string]: EventListener } = {
+  #boundBluetoothCharacteristicEventListeners: {
+    [eventType: string]: EventListener;
+  } = {
     characteristicvaluechanged: this.#onCharacteristicvaluechanged.bind(this),
   };
-  #boundBluetoothDeviceEventListeners: { [eventType: string]: EventListener } = {
-    gattserverdisconnected: this.#onGattserverdisconnected.bind(this),
-  };
+  #boundBluetoothDeviceEventListeners: { [eventType: string]: EventListener } =
+    {
+      gattserverdisconnected: this.#onGattserverdisconnected.bind(this),
+    };
 
   static get isSupported() {
     return Boolean(bluetooth);
@@ -60,7 +74,7 @@ class WebBluetoothConnectionManager extends BluetoothConnectionManager {
     return "webBluetooth";
   }
 
-  #device!: BluetoothDevice | undefined;
+  #device?: BluetoothDevice;
   get device() {
     return this.#device;
   }
@@ -70,7 +84,10 @@ class WebBluetoothConnectionManager extends BluetoothConnectionManager {
       return;
     }
     if (this.#device) {
-      removeEventListeners(this.#device, this.#boundBluetoothDeviceEventListeners);
+      removeEventListeners(
+        this.#device,
+        this.#boundBluetoothDeviceEventListeners
+      );
     }
     if (newDevice) {
       addEventListeners(newDevice, this.#boundBluetoothDeviceEventListeners);
@@ -86,7 +103,8 @@ class WebBluetoothConnectionManager extends BluetoothConnectionManager {
   }
 
   #services: Map<BluetoothServiceName, BluetoothService> = new Map();
-  #characteristics: Map<BluetoothCharacteristicName, BluetoothCharacteristic> = new Map();
+  #characteristics: Map<BluetoothCharacteristicName, BluetoothCharacteristic> =
+    new Map();
 
   async connect() {
     await super.connect();
@@ -129,7 +147,10 @@ class WebBluetoothConnectionManager extends BluetoothConnectionManager {
       const service = services[serviceIndex] as BluetoothService;
       _console.log({ service });
       const serviceName = getServiceNameFromUUID(service.uuid)!;
-      _console.assertWithError(serviceName, `no name found for service uuid "${service.uuid}"`);
+      _console.assertWithError(
+        serviceName,
+        `no name found for service uuid "${service.uuid}"`
+      );
       _console.log(`got "${serviceName}" service`);
       service.name = serviceName;
       this.#services.set(serviceName, service);
@@ -137,20 +158,33 @@ class WebBluetoothConnectionManager extends BluetoothConnectionManager {
       const characteristics = await service.getCharacteristics();
       _console.log(`got characteristics for "${serviceName}" service`);
       for (const characteristicIndex in characteristics) {
-        const characteristic = characteristics[characteristicIndex] as BluetoothCharacteristic;
+        const characteristic = characteristics[
+          characteristicIndex
+        ] as BluetoothCharacteristic;
         _console.log({ characteristic });
-        const characteristicName = getCharacteristicNameFromUUID(characteristic.uuid)!;
+        const characteristicName = getCharacteristicNameFromUUID(
+          characteristic.uuid
+        )!;
         _console.assertWithError(
           Boolean(characteristicName),
           `no name found for characteristic uuid "${characteristic.uuid}" in "${serviceName}" service`
         );
-        _console.log(`got "${characteristicName}" characteristic in "${serviceName}" service`);
+        _console.log(
+          `got "${characteristicName}" characteristic in "${serviceName}" service`
+        );
         characteristic.name = characteristicName;
         this.#characteristics.set(characteristicName, characteristic);
-        addEventListeners(characteristic, this.#boundBluetoothCharacteristicEventListeners);
-        const characteristicProperties = characteristic.properties || getCharacteristicProperties(characteristicName);
+        addEventListeners(
+          characteristic,
+          this.#boundBluetoothCharacteristicEventListeners
+        );
+        const characteristicProperties =
+          characteristic.properties ||
+          getCharacteristicProperties(characteristicName);
         if (characteristicProperties.notify) {
-          _console.log(`starting notifications for "${characteristicName}" characteristic`);
+          _console.log(
+            `starting notifications for "${characteristicName}" characteristic`
+          );
           await characteristic.startNotifications();
         }
         if (characteristicProperties.read) {
@@ -165,18 +199,30 @@ class WebBluetoothConnectionManager extends BluetoothConnectionManager {
   }
   async #removeEventListeners() {
     if (this.device) {
-      removeEventListeners(this.device, this.#boundBluetoothDeviceEventListeners);
+      removeEventListeners(
+        this.device,
+        this.#boundBluetoothDeviceEventListeners
+      );
     }
 
-    const promises = Array.from(this.#characteristics.keys()).map((characteristicName) => {
-      const characteristic = this.#characteristics.get(characteristicName)!;
-      removeEventListeners(characteristic, this.#boundBluetoothCharacteristicEventListeners);
-      const characteristicProperties = characteristic.properties || getCharacteristicProperties(characteristicName);
-      if (characteristicProperties.notify) {
-        _console.log(`stopping notifications for "${characteristicName}" characteristic`);
-        return characteristic.stopNotifications();
+    const promises = Array.from(this.#characteristics.keys()).map(
+      (characteristicName) => {
+        const characteristic = this.#characteristics.get(characteristicName)!;
+        removeEventListeners(
+          characteristic,
+          this.#boundBluetoothCharacteristicEventListeners
+        );
+        const characteristicProperties =
+          characteristic.properties ||
+          getCharacteristicProperties(characteristicName);
+        if (characteristicProperties.notify) {
+          _console.log(
+            `stopping notifications for "${characteristicName}" characteristic`
+          );
+          return characteristic.stopNotifications();
+        }
       }
-    });
+    );
 
     return Promise.allSettled(promises);
   }
@@ -203,10 +249,18 @@ class WebBluetoothConnectionManager extends BluetoothConnectionManager {
       `no name found for characteristic with uuid "${characteristic.uuid}"`
     );
 
-    _console.log(`oncharacteristicvaluechanged for "${characteristicName}" characteristic`);
+    _console.log(
+      `oncharacteristicvaluechanged for "${characteristicName}" characteristic`
+    );
     const dataView = characteristic.value!;
-    _console.assertWithError(dataView, `no data found for "${characteristicName}" characteristic`);
-    _console.log(`data for "${characteristicName}" characteristic`, Array.from(new Uint8Array(dataView.buffer)));
+    _console.assertWithError(
+      dataView,
+      `no data found for "${characteristicName}" characteristic`
+    );
+    _console.log(
+      `data for "${characteristicName}" characteristic`,
+      Array.from(new Uint8Array(dataView.buffer))
+    );
 
     try {
       this.onCharacteristicValueChanged(characteristicName, dataView);
@@ -215,13 +269,21 @@ class WebBluetoothConnectionManager extends BluetoothConnectionManager {
     }
   }
 
-  async writeCharacteristic(characteristicName: BluetoothCharacteristicName, data: ArrayBuffer) {
+  async writeCharacteristic(
+    characteristicName: BluetoothCharacteristicName,
+    data: ArrayBuffer
+  ) {
     super.writeCharacteristic(characteristicName, data);
 
     const characteristic = this.#characteristics.get(characteristicName)!;
-    _console.assertWithError(characteristic, `${characteristicName} characteristic not found`);
+    _console.assertWithError(
+      characteristic,
+      `${characteristicName} characteristic not found`
+    );
     _console.log("writing characteristic", characteristic, data);
-    const characteristicProperties = characteristic.properties || getCharacteristicProperties(characteristicName);
+    const characteristicProperties =
+      characteristic.properties ||
+      getCharacteristicProperties(characteristicName);
     if (characteristicProperties.writeWithoutResponse) {
       _console.log("writing without response");
       await characteristic.writeValueWithoutResponse(data);
@@ -250,8 +312,6 @@ class WebBluetoothConnectionManager extends BluetoothConnectionManager {
   }
   async reconnect() {
     await super.reconnect();
-    _console.log("attempting to reconnect...");
-    this.status = "connecting";
     try {
       await this.server!.connect();
     } catch (error) {
@@ -268,6 +328,11 @@ class WebBluetoothConnectionManager extends BluetoothConnectionManager {
       this.status = "notConnected";
     }
   }
+
+  remove() {
+    super.remove();
+    this.device = undefined;
+  }
 }
 
 export default WebBluetoothConnectionManager;

package/src/connection/bluetooth/bluetoothUUIDs.ts

@@ -15,11 +15,16 @@ if (isInBrowser) {
 
 function generateBluetoothUUID(value: string): BluetoothServiceUUID {
   _console.assertTypeWithError(value, "string");
-  _console.assertWithError(value.length == 4, "value must be 4 characters long");
-  return `ea6da725-${value}-4f9b-893d-c3913e33b39f`;
+  _console.assertWithError(
+    value.length == 4,
+    "value must be 4 characters long"
+  );
+  return `ea6d${value}-a725-4f9b-893d-c3913e33b39f`;
 }
 
-function stringToCharacteristicUUID(identifier: string): BluetoothCharacteristicUUID {
+function stringToCharacteristicUUID(
+  identifier: string
+): BluetoothCharacteristicUUID {
   return BluetoothUUID?.getCharacteristic?.(identifier);
 }
 
@@ -27,19 +32,32 @@ function stringToServiceUUID(identifier: string): BluetoothServiceUUID {
   return BluetoothUUID?.getService?.(identifier);
 }
 
-export type BluetoothServiceName = "deviceInformation" | "battery" | "main" | "smp";
-import { DeviceInformationMessageType } from "../../DeviceInformationManager.ts";
-export type BluetoothCharacteristicName = DeviceInformationMessageType | "batteryLevel" | "rx" | "tx" | "smp";
+export type BluetoothServiceName =
+  | "deviceInformation"
+  | "battery"
+  | "main"
+  | "smp";
+import { DeviceInformationType } from "../../DeviceInformationManager.ts";
+export type BluetoothCharacteristicName =
+  | DeviceInformationType
+  | "batteryLevel"
+  | "rx"
+  | "tx"
+  | "smp";
 
 interface BluetoothCharacteristicInformation {
   uuid: BluetoothCharacteristicUUID;
 }
 interface BluetoothServiceInformation {
   uuid: BluetoothServiceUUID;
-  characteristics: { [characteristicName in BluetoothCharacteristicName]?: BluetoothCharacteristicInformation };
+  characteristics: {
+    [characteristicName in BluetoothCharacteristicName]?: BluetoothCharacteristicInformation;
+  };
 }
 interface BluetoothServicesInformation {
-  services: { [serviceName in BluetoothServiceName]: BluetoothServiceInformation };
+  services: {
+    [serviceName in BluetoothServiceName]: BluetoothServiceInformation;
+  };
 }
 const bluetoothUUIDs: BluetoothServicesInformation = Object.freeze({
   services: {
@@ -101,9 +119,13 @@ export const optionalServiceUUIDs = [
 ];
 export const allServiceUUIDs = [...serviceUUIDs, ...optionalServiceUUIDs];
 
-export function getServiceNameFromUUID(serviceUUID: BluetoothServiceUUID): BluetoothServiceName | undefined {
+export function getServiceNameFromUUID(
+  serviceUUID: BluetoothServiceUUID
+): BluetoothServiceName | undefined {
   serviceUUID = serviceUUID.toString().toLowerCase();
-  const serviceNames = Object.keys(bluetoothUUIDs.services) as BluetoothServiceName[];
+  const serviceNames = Object.keys(
+    bluetoothUUIDs.services
+  ) as BluetoothServiceName[];
   return serviceNames.find((serviceName) => {
     const serviceInfo = bluetoothUUIDs.services[serviceName];
     let serviceInfoUUID = serviceInfo.uuid.toString();
@@ -127,7 +149,9 @@ Object.values(bluetoothUUIDs.services).forEach((serviceInfo) => {
   if (!serviceInfo.characteristics) {
     return;
   }
-  const characteristicNames = Object.keys(serviceInfo.characteristics) as BluetoothCharacteristicName[];
+  const characteristicNames = Object.keys(
+    serviceInfo.characteristics
+  ) as BluetoothCharacteristicName[];
   characteristicNames.forEach((characteristicName) => {
     const characteristicInfo = serviceInfo.characteristics[characteristicName]!;
     if (serviceUUIDs.includes(serviceInfo.uuid)) {
@@ -148,9 +172,12 @@ export function getCharacteristicNameFromUUID(
   characteristicUUID = characteristicUUID.toString().toLowerCase();
   var characteristicName: BluetoothCharacteristicName | undefined;
   Object.values(bluetoothUUIDs.services).some((serviceInfo) => {
-    const characteristicNames = Object.keys(serviceInfo.characteristics) as BluetoothCharacteristicName[];
+    const characteristicNames = Object.keys(
+      serviceInfo.characteristics
+    ) as BluetoothCharacteristicName[];
     characteristicName = characteristicNames.find((_characteristicName) => {
-      const characteristicInfo = serviceInfo.characteristics[_characteristicName]!;
+      const characteristicInfo =
+        serviceInfo.characteristics[_characteristicName]!;
       let characteristicInfoUUID = characteristicInfo.uuid.toString();
       if (characteristicUUID.length == 4) {
         characteristicInfoUUID = characteristicInfoUUID.slice(4, 8);