@stoprocent/noble 1.10.3 → 1.10.4

package/index.d.ts

@@ -11,203 +11,194 @@
 
 /// <reference types="node" />
 
+import events = require("events");
 
+/**
+ * @deprecated
+ */
+export declare function startScanning(callback?: (error?: Error) => void): void;
+/**
+ * @deprecated
+ */
+export declare function startScanning(serviceUUIDs: string[], callback?: (error?: Error) => void): void;
+export declare function startScanning(serviceUUIDs?: string[], allowDuplicates?: boolean, callback?: (error?: Error) => void): void;
+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 cancelConnect(peripheralUuid: string, options?: object): void;
+export declare function reset(): void;
+
+export declare function on(event: "stateChange", listener: (state: string) => void): events.EventEmitter;
+export declare function on(event: "scanStart", listener: () => void): events.EventEmitter;
+export declare function on(event: "scanStop", listener: () => void): events.EventEmitter;
+export declare function on(event: "discover", listener: (peripheral: Peripheral) => void): events.EventEmitter;
+export declare function on(event: string, listener: Function): events.EventEmitter;
+
+export declare function once(event: "stateChange", listener: (state: string) => void): events.EventEmitter;
+export declare function once(event: "scanStart", listener: () => void): events.EventEmitter;
+export declare function once(event: "scanStop", listener: () => void): events.EventEmitter;
+export declare function once(event: "discover", listener: (peripheral: Peripheral) => void): events.EventEmitter;
+export declare function once(event: string, listener: Function): events.EventEmitter;
+
+export declare function removeListener(event: "stateChange", listener: (state: string) => void): events.EventEmitter;
+export declare function removeListener(event: "scanStart", listener: () => void): events.EventEmitter;
+export declare function removeListener(event: "scanStop", listener: () => void): events.EventEmitter;
+export declare function removeListener(event: "discover", listener: (peripheral: Peripheral) => void): events.EventEmitter;
+export declare function removeListener(event: string, listener: Function): events.EventEmitter;
+
+export declare function removeAllListeners(event?: string): events.EventEmitter;
+
+export declare var state: string;
+
+export var _bindings: any;
+
+export interface ServicesAndCharacteristics {
+  services: Service[];
+  characteristics: Characteristic[];
+}
 
-import events = require("events");
+export declare class Peripheral extends events.EventEmitter {
+    id: string;
+    uuid: string;
+    address: string;
+    addressType: string;
+    connectable: boolean;
+    advertisement: Advertisement;
+    rssi: number;
+    mtu: number | null;
+    services: Service[];
+    state: 'error' | 'connecting' | 'connected' | 'disconnecting' | 'disconnected';
+
+    connect(callback?: (error: string) => void): void;
+    connectAsync(): Promise<void>;
+    disconnect(callback?: () => void): void;
+    disconnectAsync(): Promise<void>;
+    updateRssi(callback?: (error: string, rssi: number) => void): void;
+    updateRssiAsync(): Promise<number>;
+    discoverServices(): void;
+    discoverServicesAsync(): Promise<Service[]>;
+    discoverServices(serviceUUIDs: string[], callback?: (error: string, services: Service[]) => void): void;
+    discoverServicesAsync(serviceUUIDs: string[]): Promise<Service[]>;
+    discoverAllServicesAndCharacteristics(callback?: (error: string, services: Service[], characteristics: Characteristic[]) => void): void;
+    discoverAllServicesAndCharacteristicsAsync(): Promise<ServicesAndCharacteristics>;
+    discoverSomeServicesAndCharacteristics(serviceUUIDs: string[], characteristicUUIDs: string[], callback?: (error: string, services: Service[], characteristics: Characteristic[]) => void): void;
+    discoverSomeServicesAndCharacteristicsAsync(serviceUUIDs: string[], characteristicUUIDs: string[]): Promise<ServicesAndCharacteristics>;
+    cancelConnect(options?: object): void;
+
+    readHandle(handle: number, callback: (error: string, data: Buffer) => void): void;
+    readHandleAsync(handle: number): Promise<Buffer>;
+    writeHandle(handle: number, data: Buffer, withoutResponse: boolean, callback: (error: string) => void): void;
+    writeHandleAsync(handle: number, data: Buffer, withoutResponse: boolean): Promise<void>;
+    toString(): string;
+
+    on(event: "connect", listener: (error: string) => void): this;
+    on(event: "disconnect", listener: (error: string) => void): this;
+    on(event: "rssiUpdate", listener: (rssi: number) => void): this;
+    on(event: "servicesDiscover", listener: (services: Service[]) => void): this;
+    on(event: string, listener: Function): this;
+
+    once(event: "connect", listener: (error: string) => void): this;
+    once(event: "disconnect", listener: (error: string) => void): this;
+    once(event: "rssiUpdate", listener: (rssi: number) => void): this;
+    once(event: "servicesDiscover", listener: (services: Service[]) => void): this;
+    once(event: string, listener: Function): this;
+}
+
+export interface Advertisement {
+    localName: string;
+    serviceData: Array<{
+        uuid: string,
+        data: Buffer
+    }>;
+    txPowerLevel: number;
+    manufacturerData: Buffer;
+    serviceUuids: string[];
+}
+
+export declare class Service extends events.EventEmitter {
+    uuid: string;
+    name: string;
+    type: string;
+    includedServiceUuids: string[];
+    characteristics: Characteristic[];
+
+    discoverIncludedServices(): void;
+    discoverIncludedServicesAsync(): Promise<string[]>;
+    discoverIncludedServices(serviceUUIDs: string[], callback?: (error: string, includedServiceUuids: string[]) => void): void;
+    discoverIncludedServicesAsync(serviceUUIDs: string[]): Promise<string[]>;
+    discoverCharacteristics(): void;
+    discoverCharacteristicsAsync(): Promise<Characteristic[]>;
+    discoverCharacteristics(characteristicUUIDs: string[], callback?: (error: string, characteristics: Characteristic[]) => void): void;
+    discoverCharacteristicsAsync(characteristicUUIDs: string[]): Promise<Characteristic[]>;
+    toString(): string;
+
+    on(event: "includedServicesDiscover", listener: (includedServiceUuids: string[]) => void): this;
+    on(event: "characteristicsDiscover", listener: (characteristics: Characteristic[]) => void): this;
+    on(event: string, listener: Function): this;
+
+    once(event: "includedServicesDiscover", listener: (includedServiceUuids: string[]) => void): this;
+    once(event: "characteristicsDiscover", listener: (characteristics: Characteristic[]) => void): this;
+    once(event: string, listener: Function): this;
+}
+
+export declare class Characteristic extends events.EventEmitter {
+    uuid: string;
+    name: string;
+    type: string;
+    properties: string[];
+    descriptors: Descriptor[];
+
+    read(callback?: (error: string, data: Buffer) => void): void;
+    readAsync(): Promise<Buffer>;
+    write(data: Buffer, withoutResponse: boolean, callback?: (error: string) => void): void;
+    writeAsync(data: Buffer, withoutResponse: boolean): Promise<void>;
+    broadcast(broadcast: boolean, callback?: (error: string) => void): void;
+    broadcastAsync(broadcast: boolean): Promise<void>;
+    notify(notify: boolean, callback?: (error: string) => void): void;
+    notifyAsync(notify: boolean): Promise<void>;
+    discoverDescriptors(callback?: (error: string, descriptors: Descriptor[]) => void): void;
+    discoverDescriptorsAsync(): Promise<Descriptor[]>;
+    toString(): string;
+    subscribe(callback?: (error: string) => void): void;
+    subscribeAsync(): Promise<void>;
+    unsubscribe(callback?: (error: string) => void): void;
+    unsubscribeAsync(): Promise<void>;
+
+    on(event: "read", listener: (data: Buffer, isNotification: boolean) => void): this;
+    on(event: "write", withoutResponse: boolean, listener: (error: string) => void): this;
+    on(event: "broadcast", listener: (state: string) => void): this;
+    on(event: "notify", listener: (state: string) => void): this;
+    on(event: "data", listener: (data: Buffer, isNotification: boolean) => void): this;
+    on(event: "descriptorsDiscover", listener: (descriptors: Descriptor[]) => void): this;
+    on(event: string, listener: Function): this;
+    on(event: string, option: boolean, listener: Function): this;
+
+    once(event: "read", listener: (data: Buffer, isNotification: boolean) => void): this;
+    once(event: "write", withoutResponse: boolean, listener: (error: string) => void): this;
+    once(event: "broadcast", listener: (state: string) => void): this;
+    once(event: "notify", listener: (state: string) => void): this;
+    once(event: "data", listener: (data: Buffer, isNotification: boolean) => void): this;
+    once(event: "descriptorsDiscover", listener: (descriptors: Descriptor[]) => void): this;
+    once(event: string, listener: Function): this;
+    once(event: string, option: boolean, listener: Function): this;
+}
+
+export declare class Descriptor extends events.EventEmitter {
+    uuid: string;
+    name: string;
+    type: string;
+
+    readValue(callback?: (error: string, data: Buffer) => void): void;
+    readValueAsync(): Promise<Buffer>;
+    writeValue(data: Buffer, callback?: (error: string) => void): void;
+    writeValueAsync(data: Buffer): Promise<void>;
+    toString(): string;
+
+    on(event: "valueRead", listener: (error: string, data: Buffer) => void): this;
+    on(event: "valueWrite", listener: (error: string) => void): this;
+    on(event: string, listener: Function): this;
 
-declare function noble(option?: any): noble.Noble;
-
-declare namespace noble
-{
-    export interface Noble {
-        /**
-         * @deprecated
-         */
-        startScanning(callback?: (error?: Error) => void): void;
-        /**
-         * @deprecated
-         */
-        startScanning(serviceUUIDs: string[], callback?: (error?: Error) => void): void;
-        startScanning(serviceUUIDs?: string[], allowDuplicates?: boolean, callback?: (error?: Error) => void): void;
-        startScanningAsync(serviceUUIDs?: string[], allowDuplicates?: boolean): Promise<void>;
-        stopScanning(callback?: () => void): void;
-        stopScanningAsync(): Promise<void>;
-        cancelConnect(peripheralUuid: string, options?: object): void;
-        reset(): void;
-
-        on(event: "stateChange", listener: (state: string) => void): events.EventEmitter;
-        on(event: "scanStart", listener: () => void): events.EventEmitter;
-        on(event: "scanStop", listener: () => void): events.EventEmitter;
-        on(event: "discover", listener: (peripheral: Peripheral) => void): events.EventEmitter;
-        on(event: string, listener: Function): events.EventEmitter;
-
-        once(event: "stateChange", listener: (state: string) => void): events.EventEmitter;
-        once(event: "scanStart", listener: () => void): events.EventEmitter;
-        once(event: "scanStop", listener: () => void): events.EventEmitter;
-        once(event: "discover", listener: (peripheral: Peripheral) => void): events.EventEmitter;
-        once(event: string, listener: Function): events.EventEmitter;
-
-        removeListener(event: "stateChange", listener: (state: string) => void): events.EventEmitter;
-        removeListener(event: "scanStart", listener: () => void): events.EventEmitter;
-        removeListener(event: "scanStop", listener: () => void): events.EventEmitter;
-        removeListener(event: "discover", listener: (peripheral: Peripheral) => void): events.EventEmitter;
-        removeListener(event: string, listener: Function): events.EventEmitter;
-
-        removeAllListeners(event?: string): events.EventEmitter;
-
-        state: string;
-
-        _bindings: any;
-    }
-
-    export interface ServicesAndCharacteristics {
-        services: Service[];
-        characteristics: Characteristic[];
-    }
-
-    export class Peripheral extends events.EventEmitter {
-        id: string;
-        uuid: string;
-        address: string;
-        addressType: string;
-        connectable: boolean;
-        advertisement: Advertisement;
-        rssi: number;
-        services: Service[];
-        state: 'error' | 'connecting' | 'connected' | 'disconnecting' | 'disconnected';
-
-        connect(callback?: (error: string) => void): void;
-        connectAsync(): Promise<void>;
-        disconnect(callback?: () => void): void;
-        disconnectAsync(): Promise<void>;
-        updateRssi(callback?: (error: string, rssi: number) => void): void;
-        updateRssiAsync(): Promise<number>;
-        discoverServices(): void;
-        discoverServicesAsync(): Promise<Service[]>;
-        discoverServices(serviceUUIDs: string[], callback?: (error: string, services: Service[]) => void): void;
-        discoverServicesAsync(serviceUUIDs: string[]): Promise<Service[]>;
-        discoverAllServicesAndCharacteristics(callback?: (error: string, services: Service[], characteristics: Characteristic[]) => void): void;
-        discoverAllServicesAndCharacteristicsAsync(): Promise<ServicesAndCharacteristics>;
-        discoverSomeServicesAndCharacteristics(serviceUUIDs: string[], characteristicUUIDs: string[], callback?: (error: string, services: Service[], characteristics: Characteristic[]) => void): void;
-        discoverSomeServicesAndCharacteristicsAsync(serviceUUIDs: string[], characteristicUUIDs: string[]): Promise<ServicesAndCharacteristics>;
-        cancelConnect(options?: object): void;
-
-        readHandle(handle: number, callback: (error: string, data: Buffer) => void): void;
-        readHandleAsync(handle: number): Promise<Buffer>;
-        writeHandle(handle: number, data: Buffer, withoutResponse: boolean, callback: (error: string) => void): void;
-        writeHandleAsync(handle: number, data: Buffer, withoutResponse: boolean): Promise<void>;
-        toString(): string;
-
-        on(event: "connect", listener: (error: string) => void): this;
-        on(event: "disconnect", listener: (error: string) => void): this;
-        on(event: "rssiUpdate", listener: (rssi: number) => void): this;
-        on(event: "servicesDiscover", listener: (services: Service[]) => void): this;
-        on(event: string, listener: Function): this;
-
-        once(event: "connect", listener: (error: string) => void): this;
-        once(event: "disconnect", listener: (error: string) => void): this;
-        once(event: "rssiUpdate", listener: (rssi: number) => void): this;
-        once(event: "servicesDiscover", listener: (services: Service[]) => void): this;
-        once(event: string, listener: Function): this;
-    }
-
-    export interface Advertisement {
-        localName: string;
-        serviceData: Array<{
-            uuid: string,
-            data: Buffer
-        }>;
-        txPowerLevel: number;
-        manufacturerData: Buffer;
-        serviceUuids: string[];
-    }
-
-    export class Service extends events.EventEmitter {
-        uuid: string;
-        name: string;
-        type: string;
-        includedServiceUuids: string[];
-        characteristics: Characteristic[];
-
-        discoverIncludedServices(): void;
-        discoverIncludedServicesAsync(): Promise<string[]>;
-        discoverIncludedServices(serviceUUIDs: string[], callback?: (error: string, includedServiceUuids: string[]) => void): void;
-        discoverIncludedServicesAsync(serviceUUIDs: string[]): Promise<string[]>;
-        discoverCharacteristics(): void;
-        discoverCharacteristicsAsync(): Promise<Characteristic[]>;
-        discoverCharacteristics(characteristicUUIDs: string[], callback?: (error: string, characteristics: Characteristic[]) => void): void;
-        discoverCharacteristicsAsync(characteristicUUIDs: string[]): Promise<Characteristic[]>;
-        toString(): string;
-
-        on(event: "includedServicesDiscover", listener: (includedServiceUuids: string[]) => void): this;
-        on(event: "characteristicsDiscover", listener: (characteristics: Characteristic[]) => void): this;
-        on(event: string, listener: Function): this;
-
-        once(event: "includedServicesDiscover", listener: (includedServiceUuids: string[]) => void): this;
-        once(event: "characteristicsDiscover", listener: (characteristics: Characteristic[]) => void): this;
-        once(event: string, listener: Function): this;
-    }
-
-    export class Characteristic extends events.EventEmitter {
-        uuid: string;
-        name: string;
-        type: string;
-        properties: string[];
-        descriptors: Descriptor[];
-
-        read(callback?: (error: string, data: Buffer) => void): void;
-        readAsync(): Promise<Buffer>;
-        write(data: Buffer, withoutResponse: boolean, callback?: (error: string) => void): void;
-        writeAsync(data: Buffer, withoutResponse: boolean): Promise<void>;
-        broadcast(broadcast: boolean, callback?: (error: string) => void): void;
-        broadcastAsync(broadcast: boolean): Promise<void>;
-        notify(notify: boolean, callback?: (error: string) => void): void;
-        notifyAsync(notify: boolean): Promise<void>;
-        discoverDescriptors(callback?: (error: string, descriptors: Descriptor[]) => void): void;
-        discoverDescriptorsAsync(): Promise<Descriptor[]>;
-        toString(): string;
-        subscribe(callback?: (error: string) => void): void;
-        subscribeAsync(): Promise<void>;
-        unsubscribe(callback?: (error: string) => void): void;
-        unsubscribeAsync(): Promise<void>;
-
-        on(event: "read", listener: (data: Buffer, isNotification: boolean) => void): this;
-        on(event: "write", withoutResponse: boolean, listener: (error: string) => void): this;
-        on(event: "broadcast", listener: (state: string) => void): this;
-        on(event: "notify", listener: (state: string) => void): this;
-        on(event: "data", listener: (data: Buffer, isNotification: boolean) => void): this;
-        on(event: "descriptorsDiscover", listener: (descriptors: Descriptor[]) => void): this;
-        on(event: string, listener: Function): this;
-        on(event: string, option: boolean, listener: Function): this;
-
-        once(event: "read", listener: (data: Buffer, isNotification: boolean) => void): this;
-        once(event: "write", withoutResponse: boolean, listener: (error: string) => void): this;
-        once(event: "broadcast", listener: (state: string) => void): this;
-        once(event: "notify", listener: (state: string) => void): this;
-        once(event: "data", listener: (data: Buffer, isNotification: boolean) => void): this;
-        once(event: "descriptorsDiscover", listener: (descriptors: Descriptor[]) => void): this;
-        once(event: string, listener: Function): this;
-        once(event: string, option: boolean, listener: Function): this;
-    }
-
-    export class Descriptor extends events.EventEmitter {
-        uuid: string;
-        name: string;
-        type: string;
-
-        readValue(callback?: (error: string, data: Buffer) => void): void;
-        readValueAsync(): Promise<Buffer>;
-        writeValue(data: Buffer, callback?: (error: string) => void): void;
-        writeValueAsync(data: Buffer): Promise<void>;
-        toString(): string;
-
-        on(event: "valueRead", listener: (error: string, data: Buffer) => void): this;
-        on(event: "valueWrite", listener: (error: string) => void): this;
-        on(event: string, listener: Function): this;
-
-        once(event: "valueRead", listener: (error: string, data: Buffer) => void): this;
-        once(event: "valueWrite", listener: (error: string) => void): this;
-        once(event: string, listener: Function): this;
-    }
+    once(event: "valueRead", listener: (error: string, data: Buffer) => void): this;
+    once(event: "valueWrite", listener: (error: string) => void): this;
+    once(event: string, listener: Function): this;
 }
-export = noble;

package/index.js

@@ -1,6 +1 @@
-module.exports = function (options) {
-  const Noble = require('./lib/noble');
-  const bindings = require('./lib/resolve-bindings')(options);
-
-  return new Noble(bindings);
-};
+module.exports = require('./with-custom-binding')();

package/lib/distributed/bindings.js

@@ -84,10 +84,10 @@ NobleBindings.prototype._onMessage = function (ws, event) {
     // TODO: handle duplicate peripheralUuid's
     this._peripherals[peripheralUuid] = {
       uuid: peripheralUuid,
-      address: address,
-      advertisement: advertisement,
-      rssi: rssi,
-      ws: ws
+      address,
+      advertisement,
+      rssi,
+      ws
     };
 
     this.emit('discover', peripheralUuid, address, addressType, connectable, advertisement, rssi);
@@ -139,8 +139,8 @@ NobleBindings.prototype._sendCommand = function (ws, command) {
 NobleBindings.prototype.startScanning = function (serviceUuids, allowDuplicates) {
   this._startScanCommand = {
     action: 'startScanning',
-    serviceUuids: serviceUuids,
-    allowDuplicates: allowDuplicates
+    serviceUuids,
+    allowDuplicates
   };
 
   this._sendCommand(null, this._startScanCommand);
@@ -191,7 +191,7 @@ NobleBindings.prototype.discoverServices = function (deviceUuid, uuids) {
   this._sendCommand(peripheral.ws, {
     action: 'discoverServices',
     peripheralUuid: peripheral.uuid,
-    uuids: uuids
+    uuids
   });
 };
 
@@ -201,8 +201,8 @@ NobleBindings.prototype.discoverIncludedServices = function (deviceUuid, service
   this._sendCommand(peripheral.ws, {
     action: 'discoverIncludedServices',
     peripheralUuid: peripheral.uuid,
-    serviceUuid: serviceUuid,
-    serviceUuids: serviceUuids
+    serviceUuid,
+    serviceUuids
   });
 };
 
@@ -212,8 +212,8 @@ NobleBindings.prototype.discoverCharacteristics = function (deviceUuid, serviceU
   this._sendCommand(peripheral.ws, {
     action: 'discoverCharacteristics',
     peripheralUuid: peripheral.uuid,
-    serviceUuid: serviceUuid,
-    characteristicUuids: characteristicUuids
+    serviceUuid,
+    characteristicUuids
   });
 };
 
@@ -223,8 +223,8 @@ NobleBindings.prototype.read = function (deviceUuid, serviceUuid, characteristic
   this._sendCommand(peripheral.ws, {
     action: 'read',
     peripheralUuid: peripheral.uuid,
-    serviceUuid: serviceUuid,
-    characteristicUuid: characteristicUuid
+    serviceUuid,
+    characteristicUuid
   });
 };
 
@@ -234,10 +234,10 @@ NobleBindings.prototype.write = function (deviceUuid, serviceUuid, characteristi
   this._sendCommand(peripheral.ws, {
     action: 'write',
     peripheralUuid: peripheral.uuid,
-    serviceUuid: serviceUuid,
-    characteristicUuid: characteristicUuid,
+    serviceUuid,
+    characteristicUuid,
     data: data.toString('hex'),
-    withoutResponse: withoutResponse
+    withoutResponse
   });
 };
 
@@ -247,9 +247,9 @@ NobleBindings.prototype.broadcast = function (deviceUuid, serviceUuid, character
   this._sendCommand(peripheral.ws, {
     action: 'broadcast',
     peripheralUuid: peripheral.uuid,
-    serviceUuid: serviceUuid,
-    characteristicUuid: characteristicUuid,
-    broadcast: broadcast
+    serviceUuid,
+    characteristicUuid,
+    broadcast
   });
 };
 
@@ -259,9 +259,9 @@ NobleBindings.prototype.notify = function (deviceUuid, serviceUuid, characterist
   this._sendCommand(peripheral.ws, {
     action: 'notify',
     peripheralUuid: peripheral.uuid,
-    serviceUuid: serviceUuid,
-    characteristicUuid: characteristicUuid,
-    notify: notify
+    serviceUuid,
+    characteristicUuid,
+    notify
   });
 };
 
@@ -271,8 +271,8 @@ NobleBindings.prototype.discoverDescriptors = function (deviceUuid, serviceUuid,
   this._sendCommand(peripheral.ws, {
     action: 'discoverDescriptors',
     peripheralUuid: peripheral.uuid,
-    serviceUuid: serviceUuid,
-    characteristicUuid: characteristicUuid
+    serviceUuid,
+    characteristicUuid
   });
 };
 
@@ -282,9 +282,9 @@ NobleBindings.prototype.readValue = function (deviceUuid, serviceUuid, character
   this._sendCommand(peripheral.ws, {
     action: 'readValue',
     peripheralUuid: peripheral.uuid,
-    serviceUuid: serviceUuid,
-    characteristicUuid: characteristicUuid,
-    descriptorUuid: descriptorUuid
+    serviceUuid,
+    characteristicUuid,
+    descriptorUuid
   });
 };
 
@@ -294,9 +294,9 @@ NobleBindings.prototype.writeValue = function (deviceUuid, serviceUuid, characte
   this._sendCommand(peripheral.ws, {
     action: 'writeValue',
     peripheralUuid: peripheral.uuid,
-    serviceUuid: serviceUuid,
-    characteristicUuid: characteristicUuid,
-    descriptorUuid: descriptorUuid,
+    serviceUuid,
+    characteristicUuid,
+    descriptorUuid,
     data: data.toString('hex')
   });
 };
@@ -307,7 +307,7 @@ NobleBindings.prototype.readHandle = function (deviceUuid, handle) {
   this._sendCommand(peripheral.ws, {
     action: 'readHandle',
     peripheralUuid: peripheral.uuid,
-    handle: handle
+    handle
   });
 };
 
@@ -317,9 +317,9 @@ NobleBindings.prototype.writeHandle = function (deviceUuid, handle, data, withou
   this._sendCommand(peripheral.ws, {
     action: 'readHandle',
     peripheralUuid: peripheral.uuid,
-    handle: handle,
+    handle,
     data: data.toString('hex'),
-    withoutResponse: withoutResponse
+    withoutResponse
   });
 };
 

package/lib/hci-socket/bindings.js

@@ -303,9 +303,7 @@ NobleBindings.prototype.onLeConnComplete = function (
       this.onConnectionParameterUpdateRequest.bind(this)
     );
 
-    setTimeout(() => {
-      this._gatts[handle].exchangeMtu();
-    }, 0);
+    this._gatts[handle].exchangeMtu();
   } else {
     uuid = this._pendingConnectionUuid;
     let statusMessage = Hci.STATUS_MAPPER[status] || 'HCI Error: Unknown';

package/lib/hci-socket/crypto.js

@@ -67,8 +67,8 @@ function swap (input) {
 }
 
 module.exports = {
-  r: r,
-  c1: c1,
-  s1: s1,
-  e: e
+  r,
+  c1,
+  s1,
+  e
 };

package/lib/hci-socket/gap.js

@@ -142,10 +142,12 @@ Gap.prototype.onHciLeAdvertisingReport = function (
     address,
     eir,
     previouslyDiscovered,
-    hasScanResponse
+    type
   );
 
-  debug(`advertisement = ${JSON.stringify(advertisement, null, 0)}`);
+  if (process.env.DEBUG === 'gap') {
+    debug(`advertisement = ${JSON.stringify(advertisement, null, 0)}`);
+  }
 
   const connectable =
     type === LE_META_EVENT_TYPE_SCAN_RESPONSE && previouslyDiscovered
@@ -154,13 +156,13 @@ Gap.prototype.onHciLeAdvertisingReport = function (
   const scannable = type === LE_META_EVENT_TYPE_SCANNABLE;
 
   this._discoveries[address] = {
-    address: address,
-    addressType: addressType,
-    connectable: connectable,
-    advertisement: advertisement,
-    rssi: rssi,
+    address,
+    addressType,
+    connectable,
+    advertisement,
+    rssi,
     count: discoveryCount,
-    hasScanResponse: hasScanResponse
+    hasScanResponse
   };
 
   // only report after a scan response event or if non-connectable or more than one discovery without a scan response, so more data can be collected
@@ -211,11 +213,13 @@ Gap.prototype.onHciLeExtendedAdvertisingReport = function (
     address,
     eir,
     previouslyDiscovered,
-    hasScanResponse,
+    type,
     txpower
   );
 
-  debug(`advertisement = ${JSON.stringify(advertisement, null, 0)}`);
+  if (process.env.DEBUG === 'gap') {
+    debug(`advertisement = ${JSON.stringify(advertisement, null, 0)}`);
+  }
 
   const connectable =
     type & 0x8 && previouslyDiscovered
@@ -225,13 +229,13 @@ Gap.prototype.onHciLeExtendedAdvertisingReport = function (
   const incomplete = type & LE_META_EXTENDED_EVENT_TYPE_INCOMPLETE_MASK ? 1 : 0;
 
   this._discoveries[address] = {
-    address: address,
-    addressType: addressType,
-    connectable: connectable,
-    advertisement: advertisement,
-    rssi: rssi,
+    address,
+    addressType,
+    connectable,
+    advertisement,
+    rssi,
     count: discoveryCount,
-    hasScanResponse: hasScanResponse
+    hasScanResponse
   };
 
   // only report after a scan response event or if non-connectable or more than one discovery without a scan response, so more data can be collected
@@ -258,7 +262,7 @@ Gap.prototype.parseServices = function (
   address,
   eir,
   previouslyDiscovered,
-  hasScanResponse,
+  leMetaEventType,
   txpower
 ) {
   let i = 0;
@@ -273,7 +277,7 @@ Gap.prototype.parseServices = function (
         solicitationServiceUuids: []
       };
 
-  if (!hasScanResponse) {
+  if (leMetaEventType !== LE_META_EVENT_TYPE_SCAN_RESPONSE) {
     // reset service data every non-scan response event
     advertisement.serviceData = [];
     advertisement.serviceUuids = [];