@stoprocent/noble 1.17.1 → 1.17.2

package/examples/peripheral-explorer-async.js

@@ -2,19 +2,23 @@ const noble = require('../');
 
 const directConnect = process.argv[2].toLowerCase();
 const peripheralIdOrAddress = process.argv[3].toLowerCase();
+const addressType = process.argv[4].toLowerCase() || 'random';
 
 const starTime = Date.now();
 
-noble.on('stateChange', async (state) => {
-  if (state === 'poweredOn') {
+async function main () {
+  try {
+    await noble.waitForPoweredOn();
     if (directConnect === '1') {
-      await noble.stopScanningAsync();
-      await noble.connectAsync(peripheralIdOrAddress.replace(/:/g, ''));
+      const peripheral = await noble.connectAsync(peripheralIdOrAddress.replace(/:/g, ''), { addressType });
+      await explore(peripheral);
     } else {
       await noble.startScanningAsync();
     }
+  } catch (error) {
+    console.error('Error:', error);
   }
-});
+}
 
 noble.on('discover', async (peripheral) => {
   if ([peripheral.id, peripheral.address].includes(peripheralIdOrAddress)) {
@@ -143,3 +147,5 @@ process.on('SIGTERM', function () {
   console.log('Caught interrupt signal');
   noble.stopScanning(() => process.exit());
 });
+
+main();

package/index.d.ts

@@ -13,6 +13,14 @@
 
 import events = require("events");
 
+export interface ConnectOptions {
+  addressType?: 'public' | 'random';
+  minInterval?: number;
+  maxInterval?: number;
+  latency?: number;
+  timeout?: number;
+}
+
 export declare function waitForPoweredOn(timeout?: number): Promise<void>;
 /**
  * @deprecated
@@ -26,8 +34,8 @@ export declare function startScanning(serviceUUIDs?: string[], allowDuplicates?:
 export declare function startScanningAsync(serviceUUIDs?: string[], allowDuplicates?: boolean): Promise<void>;
 export declare function stopScanning(callback?: () => void): void;
 export declare function stopScanningAsync(): Promise<void>;
-export declare function connect(peripheralUuid: string, options?: object, callback?: (error: Error | undefined, peripheral: Peripheral) => void): void;
-export declare function connectAsync(peripheralUuid: string, options?: object): Promise<Peripheral>;
+export declare function connect(peripheralUuid: string, options?: ConnectOptions, callback?: (error: Error | undefined, peripheral: Peripheral) => void): void;
+export declare function connectAsync(peripheralUuid: string, options?: ConnectOptions): Promise<Peripheral>;
 export declare function cancelConnect(peripheralUuid: string, options?: object): void;
 export declare function reset(): void;
 export declare function stop(): void;

package/lib/hci-socket/bindings.js

@@ -51,14 +51,14 @@ NobleBindings.prototype.stopScanning = function () {
   this._gap.stopScanning();
 };
 
-NobleBindings.prototype.connect = function (peripheralUuid, parameters) {
+NobleBindings.prototype.connect = function (peripheralUuid, parameters = {}) {
   let address = this._addresses[peripheralUuid];
   let addressType = this._addresseTypes[peripheralUuid] || 'random'; // Default to 'random' if type is not defined
   
   // If address is not available, generate it from the UUID using the transformation logic inline
   if (!address) {
     address = peripheralUuid.match(/.{1,2}/g).join(':'); // Converts UUID back to MAC address format
-    addressType = (parseInt(address.slice(0, 2).slice(0,2), 16) & 0x02) === 0  ? 'public' : 'random';
+    addressType = typeof(parameters) === 'object' && parameters.addressType ? parameters.addressType : 'random';
   }
 
   // Manage connection attempts

package/package.json

@@ -6,7 +6,7 @@
   "license": "MIT",
   "name": "@stoprocent/noble",
   "description": "A Node.js BLE (Bluetooth Low Energy) central library.",
-  "version": "1.17.1",
+  "version": "1.17.2",
   "repository": {
     "type": "git",
     "url": "https://github.com/stoprocent/noble.git"

package/test/lib/hci-socket/bindings.test.js

@@ -135,23 +135,23 @@ describe('hci-socket bindings', () => {
     it('missing peripheral, no queue, public address', () => {
       bindings._hci.createLeConn = fake.resolves(null);
 
-      bindings.connect('112233445566', 'parameters');
+      bindings.connect('112233445566', { addressType: 'public' });
 
       should(bindings._pendingConnectionUuid).eql('112233445566');
 
       assert.calledOnce(bindings._hci.createLeConn);
-      assert.calledWith(bindings._hci.createLeConn, '11:22:33:44:55:66', 'public', 'parameters');
+      assert.calledWith(bindings._hci.createLeConn, '11:22:33:44:55:66', 'public', { addressType: 'public' });
     });
 
     it('missing peripheral, no queue, random address', () => {
       bindings._hci.createLeConn = fake.resolves(null);
 
-      bindings.connect('f32233445566', 'parameters');
+      bindings.connect('f32233445566', { addressType: 'random' });
 
       should(bindings._pendingConnectionUuid).eql('f32233445566');
 
       assert.calledOnce(bindings._hci.createLeConn);
-      assert.calledWith(bindings._hci.createLeConn, 'f3:22:33:44:55:66', 'random', 'parameters');
+      assert.calledWith(bindings._hci.createLeConn, 'f3:22:33:44:55:66', 'random', { addressType: 'random' });
     });
 
     it('existing peripheral, no queue', () => {