@stoprocent/noble 2.3.14 → 2.3.16

package/lib/characteristic.js

@@ -1,8 +1,8 @@
-const { EventEmitter } = require('events');
+const NobleEventEmitter = require('./noble-event-emitter');
 
 const characteristics = require('./characteristics.json');
 
-class Characteristic extends EventEmitter {
+class Characteristic extends NobleEventEmitter {
   
   constructor (noble, peripheralId, serviceUuid, uuid, properties) {
     super();
@@ -81,7 +81,7 @@ class Characteristic extends EventEmitter {
     }
 
     if (callback) {
-      this.once('write', error => callback(error));
+      this.onceExclusive('write', error => callback(error));
     }
 
     this._noble.write(
@@ -134,7 +134,7 @@ class Characteristic extends EventEmitter {
     }
 
     if (callback) {
-      this.once('notify', (state, error) => callback(error, state));
+      this.onceExclusive('notify', (state, error) => callback(error, state));
     }
 
     this._noble.notify(
@@ -180,30 +180,30 @@ class Characteristic extends EventEmitter {
         } else if (notifying) {
           // Wait for more data or notify=false
           await new Promise(resolve => {
-            // Create listeners that automatically remove themselves
-            const tempDataListener = (...args) => {
+            let resolved = false;
+
+            const cleanup = () => {
+              if (resolved) return;
+              resolved = true;
               this.removeListener('data', tempDataListener);
               this.removeListener('notify', tempNotifyListener);
               resolve();
             };
-            
+
+            const tempDataListener = () => cleanup();
+
             const tempNotifyListener = (state) => {
               if (state === false) {
-                this.removeListener('data', tempDataListener);
-                this.removeListener('notify', tempNotifyListener);
-                resolve();
+                cleanup();
               }
             };
-            
-            // Set up temporary listeners
+
             this.once('data', tempDataListener);
             this.once('notify', tempNotifyListener);
-            
+
             // Clean up if we already have notifications (race condition)
             if (notifications.length > 0) {
-              this.removeListener('data', tempDataListener);
-              this.removeListener('notify', tempNotifyListener);
-              resolve();
+              cleanup();
             }
           });
         }
@@ -219,7 +219,7 @@ class Characteristic extends EventEmitter {
 
   discoverDescriptors (callback) {
     if (callback) {
-      this.once('descriptorsDiscover', (descriptors, error) => callback(error, descriptors));
+      this.onceExclusive('descriptorsDiscover', (descriptors, error) => callback(error, descriptors));
     }
 
     this._noble.discoverDescriptors(
@@ -239,7 +239,7 @@ class Characteristic extends EventEmitter {
 
   broadcast (broadcast, callback) {
     if (callback) {
-      this.once('broadcast', error => callback(error));
+      this.onceExclusive('broadcast', error => callback(error));
     }
 
     this._noble.broadcast(

package/lib/descriptor.js

@@ -1,7 +1,7 @@
-const { EventEmitter } = require('events');
+const NobleEventEmitter = require('./noble-event-emitter');
 const descriptors = require('./descriptors.json');
 
-class Descriptor extends EventEmitter {
+class Descriptor extends NobleEventEmitter {
   constructor (noble, peripheralId, serviceUuid, characteristicUuid, uuid) {
     super();
     
@@ -31,7 +31,7 @@ class Descriptor extends EventEmitter {
 
   readValue (callback) {
     if (callback) {
-      this.once('valueRead', (data, error) => callback(error, data));
+      this.onceExclusive('valueRead', (data, error) => callback(error, data));
     }
     this._noble.readValue(
       this._peripheralId,
@@ -53,7 +53,7 @@ class Descriptor extends EventEmitter {
     }
 
     if (callback) {
-      this.once('valueWrite', error => callback(error));
+      this.onceExclusive('valueWrite', error => callback(error));
     }
     this._noble.writeValue(
       this._peripheralId,

package/lib/noble-event-emitter.js

@@ -0,0 +1,27 @@
+const { EventEmitter } = require('events');
+
+class NobleEventEmitter extends EventEmitter {
+  /**
+   * Like once(), but ensures at most one listener exists for the given event.
+   * If a previous exclusive listener was registered for the same event, it is
+   * removed before the new one is added. This prevents listener accumulation
+   * when a method is called repeatedly before the event fires.
+   */
+  onceExclusive (event, callback) {
+    if (!this._exclusiveCallbacks) {
+      this._exclusiveCallbacks = new Map();
+    }
+    const prev = this._exclusiveCallbacks.get(event);
+    if (prev) {
+      this.removeListener(event, prev);
+    }
+    const wrappedCallback = (...args) => {
+      this._exclusiveCallbacks.delete(event);
+      callback(...args);
+    };
+    this._exclusiveCallbacks.set(event, wrappedCallback);
+    this.once(event, wrappedCallback);
+  }
+}
+
+module.exports = NobleEventEmitter;

package/lib/noble.js

@@ -1,13 +1,13 @@
 const debug = require('debug')('noble');
 
-const { EventEmitter } = require('events');
+const NobleEventEmitter = require('./noble-event-emitter');
 
 const Peripheral = require('./peripheral');
 const Service = require('./service');
 const Characteristic = require('./characteristic');
 const Descriptor = require('./descriptor');
 
-class Noble extends EventEmitter {
+class Noble extends NobleEventEmitter {
   
   constructor (bindings) {
     super();
@@ -142,7 +142,7 @@ class Noble extends EventEmitter {
 
   setScanParameters (interval, window, callback) {
     if (callback) {
-      this.once('scanParametersSet', callback);
+      this.onceExclusive('scanParametersSet', callback);
     }
     this._bindings.setScanParameters(interval, window);
   }
@@ -200,7 +200,7 @@ class Noble extends EventEmitter {
         }
       } else {
         if (callback) {
-          this.once('scanStart', filterDuplicates => callback(null, filterDuplicates));
+          this.onceExclusive('scanStart', filterDuplicates => callback(null, filterDuplicates));
         }
 
         this._discoveredPeripherals.clear();
@@ -235,7 +235,7 @@ class Noble extends EventEmitter {
       return;
     }
     if (callback) {
-      this.once('scanStop', callback);
+      this.onceExclusive('scanStop', callback);
     }
     this._bindings.stopScanning();
   }
@@ -272,38 +272,33 @@ class Noble extends EventEmitter {
             } else if (scanning) {
                 // Wait for either a new device or scan stop
                 await new Promise(resolve => {
-                    const tempDiscoverListener = () => resolve();
-                    
-                    // Set up a temporary discover listener
-                    this.once('discover', tempDiscoverListener);
-                    
-                    // Set up a cleanup for when scanning stops
-                    const tempScanStopListener = () => {
+                    let resolved = false;
+                    let timeoutId = null;
+
+                    const cleanup = () => {
+                        if (resolved) return;
+                        resolved = true;
                         this.removeListener('discover', tempDiscoverListener);
+                        this.removeListener('scanStop', tempScanStopListener);
+                        if (timeoutId) clearTimeout(timeoutId);
                         resolve();
                     };
+
+                    const tempDiscoverListener = () => cleanup();
+                    const tempScanStopListener = () => cleanup();
+
+                    this.once('discover', tempDiscoverListener);
                     this.once('scanStop', tempScanStopListener);
-                    
+
                     // Handle race condition where a device might arrive during promise setup
                     if (deviceQueue.length > 0) {
-                        this.removeListener('discover', tempDiscoverListener);
-                        this.removeListener('scanStop', tempScanStopListener);
-                        resolve();
+                        cleanup();
+                        return;
                     }
-                    
-                    // Optional: Add a maximum wait time, but with proper cleanup
-                    // This can be removed to eliminate timer dependency
+
+                    // Add a maximum wait time with proper cleanup
                     if (scanning) {
-                        const timeoutId = setTimeout(() => {
-                            this.removeListener('discover', tempDiscoverListener);
-                            this.removeListener('scanStop', tempScanStopListener);
-                            resolve();
-                        }, 1000);
-                        
-                        // Make sure we clear the timeout if we resolve before timeout
-                        const clearTimeoutFn = () => clearTimeout(timeoutId);
-                        this.once('discover', clearTimeoutFn);
-                        this.once('scanStop', clearTimeoutFn);
+                        timeoutId = setTimeout(() => cleanup(), 1000);
                     }
                 });
             }
@@ -383,7 +378,7 @@ class Noble extends EventEmitter {
     // Check if callback is a function
     if (typeof callback === 'function') {
       // Add a one-time listener for this specific event
-      this.once(`connect:${identifier}`, error => callback(error, this._peripherals.get(identifier)));
+      this.onceExclusive(`connect:${identifier}`, error => callback(error, this._peripherals.get(identifier)));
     }
 
     // Proceed to initiate the connection

package/lib/peripheral.js

@@ -1,6 +1,6 @@
-const { EventEmitter } = require('events');
+const NobleEventEmitter = require('./noble-event-emitter');
 
-class Peripheral extends EventEmitter {
+class Peripheral extends NobleEventEmitter {
   constructor (noble, id, address, addressType, connectable, advertisement, rssi, scannable) {
     super();
     this._noble = noble;
@@ -40,7 +40,7 @@ class Peripheral extends EventEmitter {
     }
 
     if (callback) {
-      this.once('connect', error => callback(error));
+      this.onceExclusive('connect', error => callback(error));
     }
 
     if (this.state === 'connected') {
@@ -66,7 +66,7 @@ class Peripheral extends EventEmitter {
 
   disconnect (callback) {
     if (callback) {
-      this.once('disconnect', () => callback(null));
+      this.onceExclusive('disconnect', () => callback(null));
     }
     this.state = 'disconnecting';
     this._noble.disconnect(this.id);
@@ -80,7 +80,7 @@ class Peripheral extends EventEmitter {
 
   updateRssi (callback) {
     if (callback) {
-      this.once('rssiUpdate', (rssi, error) => callback(error, rssi));
+      this.onceExclusive('rssiUpdate', (rssi, error) => callback(error, rssi));
     }
     this._noble.updateRssi(this.id);
   }
@@ -95,7 +95,7 @@ class Peripheral extends EventEmitter {
 
   discoverServices (uuids, callback) {
     if (callback) {
-      this.once('servicesDiscover', (services, error) => callback(error, services));
+      this.onceExclusive('servicesDiscover', (services, error) => callback(error, services));
     }
     this._noble.discoverServices(this.id, uuids);
   }
@@ -172,7 +172,7 @@ class Peripheral extends EventEmitter {
 
   readHandle (handle, callback) {
     if (callback) {
-      this.once(`handleRead${handle}`, (data, error) => callback(error, data));
+      this.onceExclusive(`handleRead${handle}`, (data, error) => callback(error, data));
     }
     this._noble.readHandle(this.id, handle);
   }
@@ -191,7 +191,7 @@ class Peripheral extends EventEmitter {
     }
 
     if (callback) {
-      this.once(`handleWrite${handle}`, (error) => callback(error));
+      this.onceExclusive(`handleWrite${handle}`, (error) => callback(error));
     }
 
     this._noble.writeHandle(this.id, handle, data, withoutResponse);

package/lib/service.js

@@ -1,7 +1,7 @@
-const { EventEmitter } = require('events');
+const NobleEventEmitter = require('./noble-event-emitter');
 const services = require('./services.json');
 
-class Service extends EventEmitter {
+class Service extends NobleEventEmitter {
 
   constructor (noble, peripheralId, uuid) {
     super();
@@ -33,7 +33,7 @@ class Service extends EventEmitter {
 
   discoverIncludedServices (serviceUuids, callback) {
     if (callback) {
-      this.once('includedServicesDiscover', (includedServiceUuids, error) => callback(error, includedServiceUuids));
+      this.onceExclusive('includedServicesDiscover', (includedServiceUuids, error) => callback(error, includedServiceUuids));
     }
 
     this._noble.discoverIncludedServices(
@@ -53,7 +53,7 @@ class Service extends EventEmitter {
 
   discoverCharacteristics (characteristicUuids, callback) {
     if (callback) {
-      this.once('characteristicsDiscover', (characteristics, error) => callback(error, characteristics));
+      this.onceExclusive('characteristicsDiscover', (characteristics, error) => callback(error, characteristics));
     }
 
     this._noble.discoverCharacteristics(

package/lib/win/src/peripheral_winrt.cc

@@ -92,16 +92,21 @@ void PeripheralWinrt::ProcessServiceData(const BluetoothLEAdvertisementDataSecti
     dr.Close();
 }
 
+static std::string advSectionToString(const winrt::Windows::Devices::Bluetooth::Advertisement::BluetoothLEAdvertisementDataSection &sec)
+{
+    std::string result;
+    result.resize(sec.Data().Length());
+    auto reader = DataReader::FromBuffer(sec.Data());
+    reader.ReadBytes(winrt::array_view<uint8_t>(
+        reinterpret_cast<uint8_t*>(result.data()), 
+        reinterpret_cast<uint8_t*>(result.data() + result.size())
+    ));
+    return result;
+}
+
 void PeripheralWinrt::Update(const int rssiValue, const BluetoothLEAdvertisement& advertisment,
                              const BluetoothLEAdvertisementType& advertismentType)
 {
-    // Handle name
-    std::string localName = ws2s(advertisment.LocalName().c_str());
-    if (!localName.empty())
-    {
-        name = std::optional<std::string>(localName);
-    }
-
     connectable = advertismentType == BluetoothLEAdvertisementType::ConnectableUndirected ||
         advertismentType == BluetoothLEAdvertisementType::ConnectableDirected;
 
@@ -144,6 +149,18 @@ void PeripheralWinrt::Update(const int rssiValue, const BluetoothLEAdvertisement
         {
             ProcessServiceData(ds, 16);  // 16 bytes for 128-bit UUID
         }
+        else if (ds.DataType() == BluetoothLEAdvertisementDataTypes::ShortenedLocalName())
+        {
+            if (!nameIsComplete)
+            {
+                name = advSectionToString(ds); // use shortened local name if no complete name is available
+            }
+        }
+        else if (ds.DataType() == BluetoothLEAdvertisementDataTypes::CompleteLocalName())
+        {
+            name = advSectionToString(ds);
+            nameIsComplete = true; // set the flag to ignore shortened local names
+        }
     }
 
     // Handle service UUIDs

package/lib/win/src/peripheral_winrt.h

@@ -73,6 +73,7 @@ public:
     std::optional<GattSession> gattSession;
     winrt::event_token maxPduSizeChangedToken;
     std::unordered_map<winrt::guid, CachedService> cachedServices;
+    bool nameIsComplete { false }; // `name` is the Complete Local Name
 
 private:
     void GetServiceFromDevice(winrt::guid serviceUuid,

package/package.json

@@ -6,7 +6,7 @@
   "license": "MIT",
   "name": "@stoprocent/noble",
   "description": "A Node.js BLE (Bluetooth Low Energy) central library.",
-  "version": "2.3.14",
+  "version": "2.3.16",
   "repository": {
     "type": "git",
     "url": "https://github.com/stoprocent/noble.git"
@@ -34,7 +34,7 @@
     "patch-package": "^8.0.0"
   },
   "optionalDependencies": {
-    "@stoprocent/bluetooth-hci-socket": "^2.2.4"
+    "@stoprocent/bluetooth-hci-socket": "^2.2.5"
   },
   "devDependencies": {
     "@babel/eslint-parser": "^7.27.0",