@stoprocent/noble 1.19.0 → 2.0.0

package/lib/distributed/bindings.js

@@ -1,326 +0,0 @@
-const events = require('events');
-const util = require('util');
-
-const WebSocketServer = require('ws').Server;
-
-const NobleBindings = function () {
-  this._wss = new WebSocketServer({
-    port: 0xB1e
-  });
-
-  this._startScanCommand = null;
-  this._peripherals = {};
-
-  this._wss.on('connection', this._onConnection.bind(this));
-  this.on('close', this._onClose.bind(this));
-  this.on('message', this._onMessage.bind(this));
-
-  process.nextTick(() => {
-    this.emit('stateChange', 'poweredOff');
-  });
-};
-
-util.inherits(NobleBindings, events.EventEmitter);
-
-NobleBindings.prototype.init = function () {
-  // no-op
-};
-
-NobleBindings.prototype._onConnection = function (ws) {
-  const _this = this;
-
-  if (this._wss.clients.length === 1) {
-    this.emit('stateChange', 'poweredOn');
-  } else if (this._startScanCommand) {
-    this._sendCommand(ws, this._startScanCommand);
-  }
-
-  ws.on('close', () => {
-    _this.emit('close', ws);
-  });
-
-  ws.on('message', data => {
-    _this.emit('message', ws, JSON.parse(data));
-  });
-};
-
-NobleBindings.prototype._onClose = function (ws) {
-  if (this._wss.clients.length === 0) {
-    this.emit('stateChange', 'poweredOff');
-  }
-};
-
-NobleBindings.prototype._onMessage = function (ws, event) {
-  let {
-    type,
-    peripheralUuid,
-    address,
-    addressType,
-    connectable,
-    advertisement,
-    rssi,
-    serviceUuids,
-    serviceUuid,
-    includedServiceUuids,
-    characteristics,
-    characteristicUuid,
-    isNotification,
-    state,
-    descriptors,
-    descriptorUuid,
-    handle
-  } = event;
-  const data = event.data ? Buffer.from(event.data, 'hex') : null;
-
-  if (type === 'discover') {
-    advertisement = {
-      localName: advertisement.localName,
-      txPowerLevel: advertisement.txPowerLevel,
-      serviceUuids: advertisement.serviceUuids,
-      manufacturerData: (advertisement.manufacturerData ? Buffer.from(advertisement.manufacturerData, 'hex') : null),
-      serviceData: (advertisement.serviceData ? Buffer.from(advertisement.serviceData, 'hex') : null)
-    };
-
-    // TODO: handle duplicate peripheralUuid's
-    this._peripherals[peripheralUuid] = {
-      uuid: peripheralUuid,
-      address,
-      advertisement,
-      rssi,
-      ws
-    };
-
-    this.emit('discover', peripheralUuid, address, addressType, connectable, advertisement, rssi);
-  } else if (type === 'connect') {
-    this.emit('connect', peripheralUuid);
-  } else if (type === 'disconnect') {
-    this.emit('disconnect', peripheralUuid);
-  } else if (type === 'rssiUpdate') {
-    this.emit('rssiUpdate', peripheralUuid, rssi);
-  } else if (type === 'servicesDiscover') {
-    this.emit('servicesDiscover', peripheralUuid, serviceUuids);
-  } else if (type === 'includedServicesDiscover') {
-    this.emit('includedServicesDiscover', peripheralUuid, serviceUuid, includedServiceUuids);
-  } else if (type === 'characteristicsDiscover') {
-    this.emit('characteristicsDiscover', peripheralUuid, serviceUuid, characteristics);
-  } else if (type === 'read') {
-    this.emit('read', peripheralUuid, serviceUuid, characteristicUuid, data, isNotification);
-  } else if (type === 'write') {
-    this.emit('write', peripheralUuid, serviceUuid, characteristicUuid);
-  } else if (type === 'broadcast') {
-    this.emit('broadcast', peripheralUuid, serviceUuid, characteristicUuid, state);
-  } else if (type === 'notify') {
-    this.emit('notify', peripheralUuid, serviceUuid, characteristicUuid, state);
-  } else if (type === 'descriptorsDiscover') {
-    this.emit('descriptorsDiscover', peripheralUuid, serviceUuid, characteristicUuid, descriptors);
-  } else if (type === 'valueRead') {
-    this.emit('valueRead', peripheralUuid, serviceUuid, characteristicUuid, descriptorUuid, data);
-  } else if (type === 'valueWrite') {
-    this.emit('valueWrite', peripheralUuid, serviceUuid, characteristicUuid, descriptorUuid);
-  } else if (type === 'handleRead') {
-    this.emit('handleRead', peripheralUuid, handle, data);
-  } else if (type === 'handleWrite') {
-    this.emit('handleWrite', peripheralUuid, handle);
-  } else if (type === 'handleNotify') {
-    this.emit('handleNotify', peripheralUuid, handle, data);
-  }
-};
-
-NobleBindings.prototype._sendCommand = function (ws, command) {
-  const clients = ws ? [ws] : this._wss.clients;
-
-  const message = JSON.stringify(command);
-
-  for (let i = 0; i < clients.length; i++) {
-    clients[i].send(message);
-  }
-};
-
-NobleBindings.prototype.startScanning = function (serviceUuids, allowDuplicates) {
-  this._startScanCommand = {
-    action: 'startScanning',
-    serviceUuids,
-    allowDuplicates
-  };
-
-  this._sendCommand(null, this._startScanCommand);
-
-  this.emit('scanStart');
-};
-
-NobleBindings.prototype.stopScanning = function () {
-  this._startScanCommand = null;
-
-  this._sendCommand(null, {
-    action: 'stopScanning'
-  });
-
-  this.emit('scanStop');
-};
-
-NobleBindings.prototype.connect = function (deviceUuid) {
-  const peripheral = this._peripherals[deviceUuid];
-
-  this._sendCommand(peripheral.ws, {
-    action: 'connect',
-    peripheralUuid: peripheral.uuid
-  });
-};
-
-NobleBindings.prototype.disconnect = function (deviceUuid) {
-  const peripheral = this._peripherals[deviceUuid];
-
-  this._sendCommand(peripheral.ws, {
-    action: 'disconnect',
-    peripheralUuid: peripheral.uuid
-  });
-};
-
-NobleBindings.prototype.updateRssi = function (deviceUuid) {
-  const peripheral = this._peripherals[deviceUuid];
-
-  this._sendCommand(peripheral.ws, {
-    action: 'updateRssi',
-    peripheralUuid: peripheral.uuid
-  });
-};
-
-NobleBindings.prototype.discoverServices = function (deviceUuid, uuids) {
-  const peripheral = this._peripherals[deviceUuid];
-
-  this._sendCommand(peripheral.ws, {
-    action: 'discoverServices',
-    peripheralUuid: peripheral.uuid,
-    uuids
-  });
-};
-
-NobleBindings.prototype.discoverIncludedServices = function (deviceUuid, serviceUuid, serviceUuids) {
-  const peripheral = this._peripherals[deviceUuid];
-
-  this._sendCommand(peripheral.ws, {
-    action: 'discoverIncludedServices',
-    peripheralUuid: peripheral.uuid,
-    serviceUuid,
-    serviceUuids
-  });
-};
-
-NobleBindings.prototype.discoverCharacteristics = function (deviceUuid, serviceUuid, characteristicUuids) {
-  const peripheral = this._peripherals[deviceUuid];
-
-  this._sendCommand(peripheral.ws, {
-    action: 'discoverCharacteristics',
-    peripheralUuid: peripheral.uuid,
-    serviceUuid,
-    characteristicUuids
-  });
-};
-
-NobleBindings.prototype.read = function (deviceUuid, serviceUuid, characteristicUuid) {
-  const peripheral = this._peripherals[deviceUuid];
-
-  this._sendCommand(peripheral.ws, {
-    action: 'read',
-    peripheralUuid: peripheral.uuid,
-    serviceUuid,
-    characteristicUuid
-  });
-};
-
-NobleBindings.prototype.write = function (deviceUuid, serviceUuid, characteristicUuid, data, withoutResponse) {
-  const peripheral = this._peripherals[deviceUuid];
-
-  this._sendCommand(peripheral.ws, {
-    action: 'write',
-    peripheralUuid: peripheral.uuid,
-    serviceUuid,
-    characteristicUuid,
-    data: data.toString('hex'),
-    withoutResponse
-  });
-};
-
-NobleBindings.prototype.broadcast = function (deviceUuid, serviceUuid, characteristicUuid, broadcast) {
-  const peripheral = this._peripherals[deviceUuid];
-
-  this._sendCommand(peripheral.ws, {
-    action: 'broadcast',
-    peripheralUuid: peripheral.uuid,
-    serviceUuid,
-    characteristicUuid,
-    broadcast
-  });
-};
-
-NobleBindings.prototype.notify = function (deviceUuid, serviceUuid, characteristicUuid, notify) {
-  const peripheral = this._peripherals[deviceUuid];
-
-  this._sendCommand(peripheral.ws, {
-    action: 'notify',
-    peripheralUuid: peripheral.uuid,
-    serviceUuid,
-    characteristicUuid,
-    notify
-  });
-};
-
-NobleBindings.prototype.discoverDescriptors = function (deviceUuid, serviceUuid, characteristicUuid) {
-  const peripheral = this._peripherals[deviceUuid];
-
-  this._sendCommand(peripheral.ws, {
-    action: 'discoverDescriptors',
-    peripheralUuid: peripheral.uuid,
-    serviceUuid,
-    characteristicUuid
-  });
-};
-
-NobleBindings.prototype.readValue = function (deviceUuid, serviceUuid, characteristicUuid, descriptorUuid) {
-  const peripheral = this._peripherals[deviceUuid];
-
-  this._sendCommand(peripheral.ws, {
-    action: 'readValue',
-    peripheralUuid: peripheral.uuid,
-    serviceUuid,
-    characteristicUuid,
-    descriptorUuid
-  });
-};
-
-NobleBindings.prototype.writeValue = function (deviceUuid, serviceUuid, characteristicUuid, descriptorUuid, data) {
-  const peripheral = this._peripherals[deviceUuid];
-
-  this._sendCommand(peripheral.ws, {
-    action: 'writeValue',
-    peripheralUuid: peripheral.uuid,
-    serviceUuid,
-    characteristicUuid,
-    descriptorUuid,
-    data: data.toString('hex')
-  });
-};
-
-NobleBindings.prototype.readHandle = function (deviceUuid, handle) {
-  const peripheral = this._peripherals[deviceUuid];
-
-  this._sendCommand(peripheral.ws, {
-    action: 'readHandle',
-    peripheralUuid: peripheral.uuid,
-    handle
-  });
-};
-
-NobleBindings.prototype.writeHandle = function (deviceUuid, handle, data, withoutResponse) {
-  const peripheral = this._peripherals[deviceUuid];
-
-  this._sendCommand(peripheral.ws, {
-    action: 'readHandle',
-    peripheralUuid: peripheral.uuid,
-    handle,
-    data: data.toString('hex'),
-    withoutResponse
-  });
-};
-
-module.exports = NobleBindings;

package/lib/mac/src/callbacks.cc

@@ -1,222 +0,0 @@
-//
-//  callbacks.cc
-//  noble-mac-native
-//
-//  Created by Georg Vienna on 30.08.18.
-//
-#include "callbacks.h"
-
-#define _s(val) Napi::String::New(env, val)
-#define _b(val) Napi::Boolean::New(env, val)
-#define _n(val) Napi::Number::New(env, val)
-#define _u(str) toUuid(env, str)
-
-Napi::String toUuid(Napi::Env& env, const std::string& uuid) {
-    std::string str(uuid);
-    str.erase(std::remove(str.begin(), str.end(), '-'), str.end());
-    std::transform(str.begin(), str.end(), str.begin(), ::tolower);
-    return _s(str);
-}
-
-Napi::String toAddressType(Napi::Env& env, const AddressType& type) {
-    if(type == PUBLIC) {
-        return _s("public");
-    } else if (type == RANDOM) {
-        return _s("random");
-    }
-    return _s("unknown");
-}
-
-Napi::Buffer<uint8_t> toBuffer(Napi::Env& env, const Data& data) {
-    if (data.empty()) {
-        return Napi::Buffer<uint8_t>::New(env, 0);
-    }
-    return Napi::Buffer<uint8_t>::Copy(env, &data[0], data.size());
-}
-
-Napi::Array toUuidArray(Napi::Env& env, const std::vector<std::string>& data) {
-    if (data.empty()) {
-        return Napi::Array::New(env);
-    }
-    auto arr = Napi::Array::New(env, data.size());
-    for (size_t i = 0; i < data.size(); i++) {
-        arr.Set(i, _u(data[i]));
-    }
-    return arr;
-}
-
-Napi::Array toArray(Napi::Env& env, const std::vector<std::string>& data) {
-    if (data.empty()) {
-        return Napi::Array::New(env);
-    }
-    auto arr = Napi::Array::New(env, data.size());
-    for (size_t i = 0; i < data.size(); i++) {
-        arr.Set(i, _s(data[i]));
-    }
-    return arr;
-}
-
-void Emit::Wrap(const Napi::Value& receiver, const Napi::Function& callback) {
-    mCallback = std::make_shared<ThreadSafeCallback>(receiver, callback);
-}
-
-void Emit::RadioState(const std::string& state) {
-    mCallback->call([state](Napi::Env env, std::vector<napi_value>& args) {
-        // emit('stateChange', state);
-        args = { _s("stateChange"), _s(state) };
-    });
-}
-
-void Emit::ScanState(bool start) {
-    mCallback->call([start](Napi::Env env, std::vector<napi_value>& args) {
-        // emit('scanStart') emit('scanStop')
-        args = { _s(start ? "scanStart" : "scanStop") };
-    });
-}
-
-void Emit::Scan(const std::string& uuid, int rssi, const Peripheral& peripheral) {
-    auto address = peripheral.address;
-    auto addressType = peripheral.addressType;
-    auto connectable = peripheral.connectable;
-    auto name = peripheral.name;
-    auto txPowerLevel = peripheral.txPowerLevel;
-    auto manufacturerData = peripheral.manufacturerData;
-    auto serviceData = peripheral.serviceData;
-    auto serviceUuids = peripheral.serviceUuids;
-    mCallback->call([uuid, rssi, address, addressType, connectable, name, txPowerLevel, manufacturerData, serviceData, serviceUuids](Napi::Env env, std::vector<napi_value>& args) {
-        Napi::Object advertisment = Napi::Object::New(env);
-        if (std::get<1>(name)) {
-            advertisment.Set(_s("localName"), _s(std::get<0>(name)));
-        }
-
-        if (std::get<1>(txPowerLevel)) {
-            advertisment.Set(_s("txPowerLevel"), std::get<0>(txPowerLevel));
-        }
-
-        if (std::get<1>(manufacturerData)) {
-            advertisment.Set(_s("manufacturerData"), toBuffer(env, std::get<0>(manufacturerData)));
-        }
-
-        if (std::get<1>(serviceData)) {
-            auto array = std::get<0>(serviceData).empty() ? Napi::Array::New(env) : Napi::Array::New(env, std::get<0>(serviceData).size());
-            for (size_t i = 0; i < std::get<0>(serviceData).size(); i++) {
-                Napi::Object data = Napi::Object::New(env);
-                data.Set(_s("uuid"), _u(std::get<0>(serviceData)[i].first));
-                data.Set(_s("data"), toBuffer(env, std::get<0>(serviceData)[i].second));
-                array.Set(i, data);
-            }
-            advertisment.Set(_s("serviceData"), array);
-        }
-
-        if (std::get<1>(serviceUuids)) {
-            advertisment.Set(_s("serviceUuids"), toUuidArray(env, std::get<0>(serviceUuids)));
-        }
-        // emit('discover', deviceUuid, address, addressType, connectable, advertisement, rssi);
-        args = { _s("discover"), _u(uuid), _s(address), toAddressType(env, addressType), _b(connectable), advertisment, _n(rssi) };
-    });
-}
-
-void Emit::Connected(const std::string& uuid, const std::string& error) {
-    mCallback->call([uuid, error](Napi::Env env, std::vector<napi_value>& args) {
-        // emit('connect', deviceUuid) error added here
-        args = { _s("connect"), _u(uuid), error.empty() ? env.Null() : _s(error) };
-    });
-}
-
-void Emit::Disconnected(const std::string& uuid) {
-    mCallback->call([uuid](Napi::Env env, std::vector<napi_value>& args) {
-        // emit('disconnect', deviceUuid);
-        args = { _s("disconnect"), _u(uuid) };
-    });
-}
-
-void Emit::RSSI(const std::string & uuid, int rssi) {
-    mCallback->call([uuid, rssi](Napi::Env env, std::vector<napi_value>& args) {
-        // emit('rssiUpdate', deviceUuid, rssi);
-        args = { _s("rssiUpdate"), _u(uuid), _n(rssi) };
-    });
-}
-
-void Emit::ServicesDiscovered(const std::string & uuid, const std::vector<std::string>& serviceUuids) {
-    mCallback->call([uuid, serviceUuids](Napi::Env env, std::vector<napi_value>& args) {
-        // emit('servicesDiscover', deviceUuid, serviceUuids)
-        args = { _s("servicesDiscover"), _u(uuid), toUuidArray(env, serviceUuids) };
-    });
-}
-
-void Emit::IncludedServicesDiscovered(const std::string & uuid, const std::string & serviceUuid, const std::vector<std::string>& serviceUuids) {
-    mCallback->call([uuid, serviceUuid, serviceUuids](Napi::Env env, std::vector<napi_value>& args) {
-        // emit('includedServicesDiscover', deviceUuid, serviceUuid, includedServiceUuids)
-        args = { _s("includedServicesDiscover"), _u(uuid), _u(serviceUuid), toUuidArray(env, serviceUuids) };
-    });
-}
-
-void Emit::CharacteristicsDiscovered(const std::string & uuid, const std::string & serviceUuid, const std::vector<std::pair<std::string, std::vector<std::string>>>& characteristics) {
-    mCallback->call([uuid, serviceUuid, characteristics](Napi::Env env, std::vector<napi_value>& args) {
-        auto arr = characteristics.empty() ? Napi::Array::New(env) : Napi::Array::New(env, characteristics.size());
-        for (size_t i = 0; i < characteristics.size(); i++) {
-            Napi::Object characteristic = Napi::Object::New(env);
-            characteristic.Set(_s("uuid"), _u(characteristics[i].first));
-            characteristic.Set(_s("properties"), toArray(env, characteristics[i].second));
-            arr.Set(i, characteristic);
-        }
-        // emit('characteristicsDiscover', deviceUuid, serviceUuid, { uuid, properties: ['broadcast', 'read', ...]})
-        args = { _s("characteristicsDiscover"), _u(uuid), _u(serviceUuid), arr };
-    });
-}
-
-void Emit::Read(const std::string & uuid, const std::string & serviceUuid, const std::string & characteristicUuid, const Data& data, bool isNotification) {
-    mCallback->call([uuid, serviceUuid, characteristicUuid, data, isNotification](Napi::Env env, std::vector<napi_value>& args) {
-        // emit('read', deviceUuid, serviceUuid, characteristicsUuid, data, isNotification);
-        args = { _s("read"), _u(uuid), _u(serviceUuid), _u(characteristicUuid), toBuffer(env, data), _b(isNotification) };
-    });
-}
-
-void Emit::Write(const std::string & uuid, const std::string & serviceUuid, const std::string & characteristicUuid) {
-    mCallback->call([uuid, serviceUuid, characteristicUuid](Napi::Env env, std::vector<napi_value>& args) {
-        // emit('write', deviceUuid, servicesUuid, characteristicsUuid)
-        args = { _s("write"), _u(uuid), _u(serviceUuid), _u(characteristicUuid) };
-    });
-}
-
-void Emit::Notify(const std::string & uuid, const std::string & serviceUuid, const std::string & characteristicUuid, bool state) {
-    mCallback->call([uuid, serviceUuid, characteristicUuid, state](Napi::Env env, std::vector<napi_value>& args) {
-        // emit('notify', deviceUuid, servicesUuid, characteristicsUuid, state)
-        args = { _s("notify"), _u(uuid), _u(serviceUuid), _u(characteristicUuid), _b(state) };
-    });
-}
-
-void Emit::DescriptorsDiscovered(const std::string & uuid, const std::string & serviceUuid, const std::string & characteristicUuid, const std::vector<std::string>& descriptorUuids) {
-    mCallback->call([uuid, serviceUuid, characteristicUuid, descriptorUuids](Napi::Env env, std::vector<napi_value>& args) {
-        // emit('descriptorsDiscover', deviceUuid, servicesUuid, characteristicsUuid, descriptors: [uuids])
-        args = { _s("descriptorsDiscover"), _u(uuid), _u(serviceUuid), _u(characteristicUuid), toUuidArray(env, descriptorUuids) };
-    });
-}
-
-void Emit::ReadValue(const std::string & uuid, const std::string & serviceUuid, const std::string & characteristicUuid, const std::string& descriptorUuid, const Data& data) {
-    mCallback->call([uuid, serviceUuid, characteristicUuid, descriptorUuid, data](Napi::Env env, std::vector<napi_value>& args) {
-        // emit('valueRead', deviceUuid, serviceUuid, characteristicUuid, descriptorUuid, data)
-        args = { _s("valueRead"), _u(uuid), _u(serviceUuid), _u(characteristicUuid), _u(descriptorUuid), toBuffer(env, data) };
-    });
-}
-
-void Emit::WriteValue(const std::string & uuid, const std::string & serviceUuid, const std::string & characteristicUuid, const std::string& descriptorUuid) {
-    mCallback->call([uuid, serviceUuid, characteristicUuid, descriptorUuid](Napi::Env env, std::vector<napi_value>& args) {
-        // emit('valueWrite', deviceUuid, serviceUuid, characteristicUuid, descriptorUuid);
-        args = { _s("valueWrite"), _u(uuid), _u(serviceUuid), _u(characteristicUuid), _u(descriptorUuid) };
-    });
-}
-
-void Emit::ReadHandle(const std::string & uuid, int descriptorHandle, const Data& data) {
-    mCallback->call([uuid, descriptorHandle, data](Napi::Env env, std::vector<napi_value>& args) {
-        // emit('handleRead', deviceUuid, descriptorHandle, data);
-        args = { _s("handleRead"), _u(uuid), _n(descriptorHandle), toBuffer(env, data) };
-    });
-}
-
-void Emit::WriteHandle(const std::string & uuid, int descriptorHandle) {
-    mCallback->call([uuid, descriptorHandle](Napi::Env env, std::vector<napi_value>& args) {
-        // emit('handleWrite', deviceUuid, descriptorHandle);
-        args = { _s("handleWrite"), _u(uuid), _n(descriptorHandle) };
-    });
-}

package/lib/mac/src/callbacks.h

@@ -1,84 +0,0 @@
-#pragma once
-
-#include <napi.h>
-#include "peripheral.h"
-
-class ThreadSafeCallback {
-  using arg_vector_t = std::vector<napi_value>;
-  using arg_func_t = std::function<void(napi_env, arg_vector_t &)>;
-
-  static void callJsCallback(Napi::Env env,
-                             Napi::Function jsCallback,
-                             Napi::Reference<Napi::Value> *context,
-                             arg_func_t *argfn) {
-    if (argfn != nullptr) {
-      arg_vector_t args;
-
-      (*argfn)(env, args);
-      delete argfn;
-
-      if (env != nullptr && jsCallback != nullptr)
-        jsCallback.Call(context->Value(), args);
-    }
-  };
-  using tsfn_t = Napi::TypedThreadSafeFunction<
-    Napi::Reference<Napi::Value>, arg_func_t, callJsCallback>;
-
-public:
-  ThreadSafeCallback(const Napi::Value &receiver,
-                     const Napi::Function &jsCallback) {
-    if (!(receiver.IsObject() || receiver.IsFunction()))
-      throw Napi::Error::New(jsCallback.Env(),
-                             "Callback receiver must be an object or function");
-    if (!jsCallback.IsFunction())
-      throw Napi::Error::New(jsCallback.Env(), "Callback must be a function");
-
-    receiver_ = Napi::Persistent(receiver);
-    tsfn_ = tsfn_t::New(jsCallback.Env(),
-                        jsCallback,
-                        "ThreadSafeCallback callback",
-                        0, 1, &receiver_);
-  }
-  ~ThreadSafeCallback() {
-    // No further interaction with the thread safe function allowed.
-    tsfn_.Abort();
-  }
-  void call(arg_func_t arg_function) {
-    arg_func_t *argfn = new arg_func_t(arg_function);
-    if (tsfn_.BlockingCall(argfn) != napi_ok)
-      delete argfn;
-  };
-
-protected:
-  ThreadSafeCallback(const ThreadSafeCallback &) = delete;
-  ThreadSafeCallback& operator=(const ThreadSafeCallback &) = delete;
-  ThreadSafeCallback& operator=(ThreadSafeCallback &&) = delete;
-
-private:
-  Napi::Reference<Napi::Value> receiver_;
-  tsfn_t tsfn_;
-};
-
-class Emit {
-public:
-    void Wrap(const Napi::Value& receiver, const Napi::Function& callback);
-    void RadioState(const std::string& status);
-    void ScanState(bool start);
-    void Scan(const std::string& uuid, int rssi, const Peripheral& peripheral);
-    void Connected(const std::string& uuid, const std::string& error = "");
-    void Disconnected(const std::string& uuid);
-    void RSSI(const std::string& uuid, int rssi);
-    void ServicesDiscovered(const std::string& uuid, const std::vector<std::string>& serviceUuids);
-    void IncludedServicesDiscovered(const std::string& uuid, const std::string& serviceUuid, const std::vector<std::string>& serviceUuids);
-    void CharacteristicsDiscovered(const std::string& uuid, const std::string& serviceUuid, const std::vector<std::pair<std::string, std::vector<std::string>>>& characteristics);
-    void Read(const std::string& uuid, const std::string& serviceUuid, const std::string& characteristicUuid, const Data& data, bool isNotification);
-    void Write(const std::string& uuid, const std::string& serviceUuid, const std::string& characteristicUuid);
-    void Notify(const std::string& uuid, const std::string& serviceUuid, const std::string& characteristicUuid, bool state);
-    void DescriptorsDiscovered(const std::string& uuid, const std::string& serviceUuid, const std::string& characteristicUuid, const std::vector<std::string>& descriptorUuids);
-    void ReadValue(const std::string& uuid, const std::string& serviceUuid, const std::string& characteristicUuid, const std::string& descriptorUuid, const Data& data);
-    void WriteValue(const std::string& uuid, const std::string& serviceUuid, const std::string& characteristicUuid, const std::string& descriptorUuid);
-    void ReadHandle(const std::string& uuid, int descriptorHandle, const std::vector<uint8_t>& data);
-    void WriteHandle(const std::string& uuid, int descriptorHandle);
-protected:
-    std::shared_ptr<ThreadSafeCallback> mCallback;
-};

package/lib/mac/src/peripheral.h

@@ -1,23 +0,0 @@
-#pragma once
-
-using Data = std::vector<uint8_t>;
-
-enum AddressType {
-    PUBLIC,
-    RANDOM,
-    UNKNOWN,
-};
-
-class Peripheral {
-public:
-    Peripheral() : address("unknown"), addressType(UNKNOWN), connectable(false) {
-    }
-    std::string address;
-    AddressType addressType;
-    bool connectable;
-    std::pair<std::string, bool> name;
-    std::pair<int, bool> txPowerLevel;
-    std::pair<Data, bool> manufacturerData;
-    std::pair<std::vector<std::pair<std::string, Data>>, bool> serviceData;
-    std::pair<std::vector<std::string>, bool> serviceUuids;
-};

package/lib/resolve-bindings-web.js

@@ -1,9 +0,0 @@
-function resolveBindings (options) {
-  if (navigator.bluetooth && !process.env.NOBLE_WEBSOCKET) {
-    return new (require('./webbluetooth/bindings'))(options);
-  }
-
-  return new (require('./websocket/bindings'))(options);
-}
-
-module.exports = resolveBindings;