incyclist-devices 2.0.0-beta.1 → 2.0.1

package/lib/serial/index.js

@@ -34,8 +34,6 @@ const serial_interface_1 = __importDefault(require("./serial-interface"));
 exports.SerialInterface = serial_interface_1.default;
 const adapter_factory_1 = __importDefault(require("./adapter-factory"));
 exports.SerialAdapterFactory = adapter_factory_1.default;
-var tcp_1 = require("./bindings/tcp");
-Object.defineProperty(exports, "TCPBinding", { enumerable: true, get: function () { return tcp_1.TCPBinding; } });
 const adapter_1 = require("./adapter");
 Object.defineProperty(exports, "SerialIncyclistDevice", { enumerable: true, get: function () { return adapter_1.SerialIncyclistDevice; } });
 const adapter_2 = __importDefault(require("./daum/classic/adapter"));
@@ -44,6 +42,8 @@ const adapter_3 = __importDefault(require("./daum/premium/adapter"));
 exports.DaumPremiumAdapter = adapter_3.default;
 const adapter_4 = __importDefault(require("./kettler/ergo-racer/adapter"));
 exports.KettlerRacerAdapter = adapter_4.default;
+var tcp_1 = require("./bindings/tcp");
+Object.defineProperty(exports, "TCPBinding", { enumerable: true, get: function () { return tcp_1.TCPBinding; } });
 adapter_factory_1.default.getInstance().registerAdapter('Daum Classic', adapter_2.default);
 adapter_factory_1.default.getInstance().registerAdapter('Daum Premium', adapter_3.default);
 adapter_factory_1.default.getInstance().registerAdapter('Kettler Racer', adapter_4.default);

package/lib/serial/kettler/ergo-racer/adapter.d.ts

@@ -44,9 +44,6 @@ export default class KettlerRacerAdapter extends SerialIncyclistDevice {
     getID(): string;
     getName(): string;
     getPort(): string;
-    setIgnoreHrm(ignore: boolean): void;
-    setIgnorePower(ignore: boolean): void;
-    setIgnoreBike(ignore: boolean): void;
     _getComms(): SerialComms<KettlerRacerCommand>;
     _setComms(comms: SerialComms<KettlerRacerCommand>): void;
     getLogger(): EventLogger;
@@ -70,6 +67,7 @@ export default class KettlerRacerAdapter extends SerialIncyclistDevice {
     check(): Promise<boolean>;
     start(props?: any): Promise<boolean>;
     startUpdatePull(): void;
+    canSendUpdate(): boolean;
     stop(): Promise<boolean>;
     mapData(bikeData: KettlerBikeData): IncyclistBikeData;
     transformData(internalData: IncyclistBikeData, bikeData: KettlerBikeData): DeviceData;
@@ -78,7 +76,6 @@ export default class KettlerRacerAdapter extends SerialIncyclistDevice {
     sendRequests(): Promise<void>;
     bikeSync(): Promise<void>;
     sendUpdate(request: any): Promise<unknown>;
-    sendData(): void;
     refreshRequests(): void;
     processClientRequest(request: any): Promise<unknown>;
     connect(): Promise<boolean>;

package/lib/serial/kettler/ergo-racer/adapter.js

@@ -25,9 +25,6 @@ class KettlerRacerAdapter extends adapter_1.SerialIncyclistDevice {
         super(settings, props);
         this.requests = [];
         this.logger = new gd_eventlog_1.EventLogger('KettlerRacer');
-        this.ignoreHrm = false;
-        this.ignorePower = false;
-        this.ignoreBike = false;
         this.paused = false;
         this.iv = null;
         this.comms = new comms_1.default({ interface: settings.interface, port: settings.port, logger: this.logger });
@@ -61,15 +58,6 @@ class KettlerRacerAdapter extends adapter_1.SerialIncyclistDevice {
         const settings = this.settings;
         return settings.port;
     }
-    setIgnoreHrm(ignore) {
-        this.ignoreHrm = ignore;
-    }
-    setIgnorePower(ignore) {
-        this.ignorePower = ignore;
-    }
-    setIgnoreBike(ignore) {
-        this.ignoreBike = ignore;
-    }
     _getComms() {
         return this.comms;
     }
@@ -329,20 +317,21 @@ class KettlerRacerAdapter extends adapter_1.SerialIncyclistDevice {
         if (this.iv)
             return;
         this.logEvent({ message: 'start regular device update' });
-        if (this.ignoreBike && this.ignoreHrm && this.ignorePower)
-            return;
         const ivSync = setInterval(() => {
             this.bikeSync();
-        }, 1000);
+        }, this.pullFrequency);
         const ivUpdate = setInterval(() => {
-            this.sendData();
+            this.emitData(this.data);
             this.refreshRequests();
-        }, 1000);
+        }, this.pullFrequency);
         this.iv = {
             sync: ivSync,
             update: ivUpdate
         };
     }
+    canSendUpdate() {
+        return !this.isPaused();
+    }
     stop() {
         this.logEvent({ message: 'stop request' });
         return new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
@@ -386,21 +375,13 @@ class KettlerRacerAdapter extends adapter_1.SerialIncyclistDevice {
         data.heartrate = internalData.heartrate;
         data.timestamp = Date.now();
         data.deviceTime = bikeData.time;
-        if (!this.ignoreBike) {
-            data.speed = internalData.speed;
-            data.power = internalData.power;
-            data.cadence = internalData.pedalRpm;
-            data.distance = distance;
-            data.deviceDistanceCounter = bikeData.distance;
-            data.internalDistanceCounter = internalData.distanceInternal;
-            this.prevDistance = internalData.distanceInternal;
-        }
-        if (this.ignoreHrm)
-            delete this.data.heartrate;
-        if (this.ignorePower) {
-            delete this.data.power;
-            delete this.data.cadence;
-        }
+        data.speed = internalData.speed;
+        data.power = internalData.power;
+        data.cadence = internalData.pedalRpm;
+        data.distance = distance;
+        data.deviceDistanceCounter = bikeData.distance;
+        data.internalDistanceCounter = internalData.distanceInternal;
+        this.prevDistance = internalData.distanceInternal;
         return data;
     }
     update() {
@@ -415,6 +396,7 @@ class KettlerRacerAdapter extends adapter_1.SerialIncyclistDevice {
                         data = this.getCyclingMode().updateData(data);
                         this.internalData = data;
                         this.data = this.transformData(data, bikeData);
+                        this.emitData(this.data);
                     }
                     catch (err) {
                         this.logEvent({ message: 'bike update error', error: err.message });
@@ -486,9 +468,7 @@ class KettlerRacerAdapter extends adapter_1.SerialIncyclistDevice {
                 return;
             }
             this.logEvent({ message: 'bikeSync' });
-            if (!this.ignoreBike) {
-                yield this.sendRequests();
-            }
+            yield this.sendRequests();
             yield this.update();
         });
     }
@@ -500,10 +480,6 @@ class KettlerRacerAdapter extends adapter_1.SerialIncyclistDevice {
             return yield this.processClientRequest(request);
         });
     }
-    sendData() {
-        if (this.onDataFn)
-            this.onDataFn(this.data);
-    }
     refreshRequests() {
         if (this.kettlerData.cadence === 0)
             return;

package/lib/serial/serial-interface.d.ts

@@ -43,14 +43,16 @@ export default class SerialInterface extends EventEmitter implements IncyclistIn
     scanEvents: EventEmitter;
     logger: EventLogger;
     toScan: NodeJS.Timeout;
+    connected: boolean;
     static _instances: SerialInterface[];
     static getInstance(props: SerialInterfaceProps): SerialInterface;
     static _add(instance: SerialInterface): void;
     constructor(props: SerialInterfaceProps);
     setBinding(binding: BindingInterface): void;
     getName(): string;
+    isConnected(): boolean;
     connect(): Promise<boolean>;
-    disconnect(): Promise<Boolean>;
+    disconnect(): Promise<boolean>;
     openPort(path: string): Promise<SerialPortStream | null>;
     closePort(path: string): Promise<Boolean>;
     scan(props: SerialScannerProps): Promise<SerialDeviceSettings[]>;

package/lib/serial/serial-interface.js

@@ -42,6 +42,7 @@ class SinglePathScanner {
     }
     scan() {
         return __awaiter(this, void 0, void 0, function* () {
+            console.log('~~~ start SERIAL Scan', this.isScanning);
             if (this.isScanning)
                 return;
             this.isScanning = true;
@@ -52,6 +53,7 @@ class SinglePathScanner {
                 let found = false;
                 while (!found && this.isScanning) {
                     try {
+                        console.log('~~~ adapter check attempt');
                         const { protocol } = this.props;
                         let host, port;
                         if (this.serial.getName() === exports.SerialInterfaceType.TCPIP) {
@@ -60,17 +62,19 @@ class SinglePathScanner {
                         else {
                             port = this.path;
                         }
-                        const adapterSettings = { interface: this.serial, host, port, protocol };
+                        const adapterSettings = { interface: this.serial.getName(), host, port, protocol };
                         const adapter = adapters_1.default.create(adapterSettings);
                         found = yield adapter.check();
                         if (found) {
                             const name = adapter.getName();
                             resolve(Object.assign(Object.assign({}, adapterSettings), { name }));
-                            yield this.serial.closePort(this.path).catch();
                         }
+                        yield (0, utils_1.sleep)(100);
                     }
                     catch (err) {
+                        console.log('~~~ERROR', err);
                         this.logger.logEvent({ message: 'error', fn: 'scan()', error: err.message || err, stack: err.stack });
+                        yield (0, utils_1.sleep)(100);
                     }
                 }
             }));
@@ -110,6 +114,7 @@ class SerialInterface extends events_1.default {
         this.isStopScanRequested = false;
         this.scanEvents = new events_1.default();
         this.logger = props.logger || new gd_eventlog_1.EventLogger(`Serial:${ifaceName}`);
+        this.connected = false;
         this.logger.logEvent({ message: 'new serial interface', ifaceName });
         if (binding) {
             this.setBinding(binding);
@@ -123,28 +128,37 @@ class SerialInterface extends events_1.default {
     getName() {
         return this.ifaceName;
     }
+    isConnected() {
+        return this.connected;
+    }
     connect() {
         return __awaiter(this, void 0, void 0, function* () {
             const binding = serialport_1.default.getInstance().getBinding(this.ifaceName);
-            if (!binding || !this.binding)
+            if (!binding || !this.binding) {
+                this.connected = false;
                 return false;
+            }
             try {
                 const SerialPort = this.binding;
-                yield SerialPort.list();
+                const res = yield SerialPort.list();
+                this.connected = true;
                 return true;
             }
             catch (err) {
+                this.connected = false;
                 return false;
             }
         });
     }
     disconnect() {
         return __awaiter(this, void 0, void 0, function* () {
+            this.connected = false;
             return true;
         });
     }
     openPort(path) {
         return __awaiter(this, void 0, void 0, function* () {
+            console.log('~~~ SerialPort.openPort', this.ifaceName, path);
             this.logger.logEvent({ message: 'opening port', path });
             const port = serialport_1.default.getInstance().getSerialPort(this.ifaceName, { path });
             if (!port) {
@@ -160,16 +174,16 @@ class SerialInterface extends events_1.default {
                 }
             }
             return new Promise((resolve) => {
-                port.on('error', (err) => {
+                port.once('error', (err) => {
                     this.logger.logEvent({ message: 'error', path, error: err || err.message });
-                    resolve(null);
                     port.removeAllListeners();
+                    resolve(null);
                 });
                 port.once('open', () => {
                     this.logger.logEvent({ message: 'port opened', path });
-                    resolve(port);
                     port.removeAllListeners();
                     this.ports.push({ path, port });
+                    resolve(port);
                 });
                 port.open();
             });
@@ -177,6 +191,7 @@ class SerialInterface extends events_1.default {
     }
     closePort(path) {
         return __awaiter(this, void 0, void 0, function* () {
+            console.log('~~~ SerialPort.closePort', this.ifaceName, path);
             const existing = this.ports.findIndex(p => p.path === path);
             if (existing === -1)
                 return true;
@@ -200,8 +215,11 @@ class SerialInterface extends events_1.default {
     }
     scan(props) {
         return __awaiter(this, void 0, void 0, function* () {
+            console.log('~~serial scan', this.isScanning, this.isConnected());
             if (this.isScanning)
                 return [];
+            if (!this.isConnected())
+                yield this.connect();
             const binding = serialport_1.default.getInstance().getBinding(this.ifaceName);
             if (!binding || !this.binding)
                 return [];
@@ -212,28 +230,34 @@ class SerialInterface extends events_1.default {
             let toExpiresAt = Date.now() + timeout;
             if (timeout) {
                 this.toScan = setTimeout(() => {
-                    console.log('~~~ TIMEOUT');
                     timeOutExpired = true;
                     this.scanEvents.emit('timeout');
                 }, timeout);
             }
+            this.logger.logEvent({ message: 'checking for ports ' });
             this.isScanning = true;
             do {
-                if (this.getName() === 'tcpip') {
-                    const _binding = binding;
-                    paths = (yield _binding.list(port)) || [];
+                try {
+                    if (this.getName() === 'tcpip') {
+                        const _binding = binding;
+                        paths = (yield _binding.list(port)) || [];
+                    }
+                    else {
+                        paths = (yield binding.list()) || [];
+                    }
                 }
-                else {
-                    paths = (yield binding.list()) || [];
+                catch (err) {
+                    console.log('~~~ERROR', err);
                 }
-                if (paths.length === 0) {
+                if (!paths || paths.length === 0) {
                     this.logger.logEvent({ message: 'scanning: no ports detected', interface: this.ifaceName, paths: paths.map(p => p.path), timeout });
-                    (0, utils_1.sleep)(1000);
+                    yield (0, utils_1.sleep)(1000);
                 }
                 if (Date.now() > toExpiresAt)
                     timeOutExpired = true;
             } while (this.isScanning && !timeOutExpired && paths.length === 0);
             if (paths.length === 0) {
+                this.logger.logEvent({ message: 'nothing to scan ' });
                 if (this.toScan) {
                     clearTimeout(this.toScan);
                     this.toScan = null;
@@ -245,8 +269,10 @@ class SerialInterface extends events_1.default {
             try {
                 yield Promise.all(scanners.map(s => s.scan()
                     .then(device => {
-                    detected.push(device);
-                    this.emit('device', device);
+                    if (device) {
+                        detected.push(device);
+                        this.emit('device', device);
+                    }
                 })
                     .catch()));
             }

package/lib/simulator/Simulator.d.ts

@@ -35,6 +35,7 @@ export declare class Simulator extends ControllableDevice {
     isSame(device: DeviceAdapter): boolean;
     getID(): string;
     getName(): string;
+    getUniqueName(): string;
     setIgnoreHrm(ignore: any): void;
     getSupportedCyclingModes(): Array<any>;
     getDefaultCyclingMode(): CyclingMode;
@@ -48,6 +49,7 @@ export declare class Simulator extends ControllableDevice {
     faster(): void;
     slower(): void;
     update(): void;
+    canSendUpdate(): boolean;
     calculateDistance(speedKps: any, timeS: any): number;
     sendUpdate(request: any): import("../modes/cycling-mode").UpdateRequest;
 }

package/lib/simulator/Simulator.js

@@ -17,7 +17,6 @@ const adpater_1 = require("../base/adpater");
 const gd_eventlog_1 = require("gd-eventlog");
 const simulator_1 = __importDefault(require("../modes/simulator"));
 const capabilities_1 = require("../types/capabilities");
-const DEFAULT_SETTINGS = { name: 'Simulator', protocol: 'Simulator', port: '' };
 const DEFAULT_PROPS = { isBot: false };
 class Simulator extends adpater_1.ControllableDevice {
     constructor(settings, props = DEFAULT_PROPS) {
@@ -55,6 +54,7 @@ class Simulator extends adpater_1.ControllableDevice {
     }
     getID() { return Simulator.NAME; }
     getName() { return Simulator.NAME; }
+    getUniqueName() { return Simulator.NAME; }
     setIgnoreHrm(ignore) {
         this.ignoreHrm = ignore;
     }
@@ -91,6 +91,7 @@ class Simulator extends adpater_1.ControllableDevice {
     start(props) {
         return __awaiter(this, void 0, void 0, function* () {
             this.startProps = props;
+            this.paused = false;
             if (props)
                 this.setBikeProps(props);
             return new Promise((resolve) => {
@@ -186,6 +187,8 @@ class Simulator extends adpater_1.ControllableDevice {
         if (!this.isBot && startDelay && timeSinceStart < startDelay * 1000) {
             return;
         }
+        if (this.paused)
+            return;
         const prevDist = this.data.distanceInternal;
         const d = this.data;
         const prevTime = d.deviceTime;
@@ -204,12 +207,12 @@ class Simulator extends adpater_1.ControllableDevice {
         if (this.isBot) {
             this.logger.logEvent(Object.assign({ message: 'Coach update', prevDist, prevTime }, data));
         }
-        this.paused = (this.data.speed === 0);
         if (this.ignoreHrm)
             delete data.heartrate;
-        if (this.onDataFn) {
-            this.onDataFn(data);
-        }
+        this.emitData(data);
+    }
+    canSendUpdate() {
+        return true;
     }
     calculateDistance(speedKps, timeS) {
         return timeS * speedKps / 3.6;

package/lib/types/adapter.d.ts

@@ -1,17 +1,22 @@
+/// <reference types="node" />
+import EventEmitter from "events";
 import CyclingMode from "../modes/cycling-mode";
 import { IncyclistCapability } from "./capabilities";
 import { DeviceData } from "./data";
 import { DeviceProperties, DeviceSettings } from "./device";
 import { User } from "./user";
 export type OnDeviceDataCallback = (data: DeviceData) => void;
-export interface IncyclistDeviceAdapter {
+export interface IncyclistDeviceAdapter extends EventEmitter {
     connect(): Promise<boolean>;
     close(): Promise<boolean>;
     check(): Promise<boolean>;
-    isEqual(settings: DeviceSettings): any;
+    isEqual(settings: DeviceSettings): boolean;
     getCapabilities(): IncyclistCapability[];
-    hasCapability(capability: IncyclistCapability): any;
+    hasCapability(capability: IncyclistCapability): boolean;
+    addCapability(capability: IncyclistCapability): void;
+    isControllable(): boolean;
     getName(): string;
+    getUniqueName(): string;
     getSettings(): DeviceSettings;
     getDisplayName(): string;
     update(): any;
@@ -20,6 +25,8 @@ export interface IncyclistDeviceAdapter {
     pause(): Promise<boolean>;
     resume(): Promise<boolean>;
     sendUpdate(request: any): any;
+    getMaxUpdateFrequency(): any;
+    setMaxUpdateFrequency(value: number): any;
     onData(callback: OnDeviceDataCallback): any;
 }
 export interface Bike {

package/lib/types/device.d.ts

@@ -19,6 +19,9 @@ export type DeviceProperties = {
     userWeight?: number;
     bikeWeight?: number;
 };
+export interface DeviceStartProperties extends DeviceProperties {
+    timeout?: number;
+}
 export type IncyclistScanProps = {
     timeout?: number;
     logger?: EventLogger;

package/lib/types/interface.d.ts

@@ -1,3 +1,5 @@
+/// <reference types="node" />
+import EventEmitter from "events";
 import { EventLogger } from "gd-eventlog";
 import { IncyclistScanProps, DeviceSettings } from "./device";
 export type InterfaceProps = {
@@ -5,10 +7,12 @@ export type InterfaceProps = {
     logger?: EventLogger;
     log?: boolean;
 };
-export type IncyclistInterface = {
+export interface IncyclistInterface extends EventEmitter {
     getName(): string;
     setBinding(binding: any): void;
     connect(): Promise<boolean>;
-    disconnect(): Promise<Boolean>;
+    disconnect(): Promise<boolean>;
+    isConnected(): boolean;
     scan(props: IncyclistScanProps): Promise<DeviceSettings[]>;
-};
+    stopScan(): Promise<boolean>;
+}

package/package.json

@@ -1,15 +1,13 @@
 {
   "name": "incyclist-devices",
-  "version": "2.0.0-beta.1",
+  "version": "2.0.1",
   "dependencies": {
     "@serialport/bindings-interface": "^1.2.2",
     "@serialport/parser-byte-length": "^9.0.1",
     "@serialport/parser-delimiter": "^9.0.1",
     "@serialport/parser-readline": "^10.5.0",
     "@serialport/stream": "^10.5.0",
-    "@types/serialport": "^8.0.2",
-    "gd-ant-plus": "^0.0.33",
-    "incyclist-ant-plus": "^0.1.15",
+    "incyclist-ant-plus": "^0.1.18",
     "win32filetime": "^1.0.2"
   },
   "peerDependencies": {
@@ -30,7 +28,7 @@
     "lint": "eslint . --ext .ts",
     "build": "tsc",
     "test": "jest --coverage",
-    "dev": "nodemon --watch src -e ts,js --exec npm run build"
+    "dev": "tsc --watch"
   },
   "files": [
     "lib/"

package/lib/ble/adapter.d.ts

@@ -1,41 +0,0 @@
-import IncyclistDevice from "../base/adpater";
-import CyclingMode from "../modes/cycling-mode";
-import { Bike } from "../types/adapter";
-import { DeviceData } from "../types/data";
-import { DeviceProperties } from "../types/device";
-import { User } from "../types/user";
-import { BleComms } from "./ble-comms";
-import BleInterface from "./ble-interface";
-import { BleDeviceSettings } from "./types";
-export default class BleAdapter extends IncyclistDevice {
-    ble: BleInterface;
-    deviceData: any;
-    data: DeviceData;
-    dataMsgCount: number;
-    lastUpdate?: number;
-    lastDataTS: number;
-    updateFrequency: number;
-    device: BleComms;
-    constructor(settings: BleDeviceSettings, props?: DeviceProperties);
-    isEqual(settings: BleDeviceSettings): boolean;
-    resetData(): void;
-    getInterface(): string;
-    getProtocolName(): string;
-    getID(): string;
-    getName(): string;
-    onDeviceData(deviceData: any): void;
-    start(props?: DeviceProperties): Promise<any>;
-    stop(): Promise<boolean>;
-}
-export declare class BleControllableAdapter extends BleAdapter implements Bike {
-    cyclingMode: CyclingMode;
-    user?: User;
-    constructor(settings: BleDeviceSettings, props?: DeviceProperties);
-    setUser(user: User): void;
-    setBikeProps(props: DeviceProperties): void;
-    getWeight(): number;
-    getSupportedCyclingModes(): any[];
-    getDefaultCyclingMode(): CyclingMode;
-    setCyclingMode(mode: CyclingMode | string, settings?: any): void;
-    getCyclingMode(): CyclingMode;
-}

package/lib/ble/ble.d.ts

@@ -1,57 +0,0 @@
-/// <reference types="node" />
-import EventEmitter from "events";
-import { BleComms } from "./ble-comms";
-import BlePeripheralConnector from "./ble-peripheral";
-import { BleDeviceCommsClass, BleDeviceSettings, BlePeripheral, ConnectProps } from "./types";
-export interface BleBinding extends EventEmitter {
-    startScanning(serviceUUIDs?: string[], allowDuplicates?: boolean, callback?: (error?: Error) => void): void;
-    stopScanning(callback?: () => void): void;
-    _bindings: any;
-    state: string;
-}
-export type BleScanProps = {
-    timeout?: number;
-    deviceTypes?: (typeof BleComms)[];
-    requested?: BleComms | BleDeviceSettings;
-    isBackgroundScan?: boolean;
-};
-export declare class BleBindingWrapper {
-    protected binding: BleBinding;
-    constructor(binding: BleBinding);
-    open(): {
-        err: Error;
-        opened: boolean;
-    };
-    get(): BleBinding;
-}
-export declare abstract class BleInterfaceClass extends EventEmitter {
-    binding: BleBinding;
-    constructor(props?: {
-        binding?: BleBinding;
-    });
-    abstract connect(props: ConnectProps): Promise<boolean>;
-    abstract scan(props: BleScanProps): Promise<BleDeviceCommsClass[]>;
-    abstract stopScan(): Promise<boolean>;
-    abstract disconnect(): Promise<boolean>;
-    abstract onDisconnect(peripheral: BlePeripheral): void;
-    abstract isScanning(): boolean;
-    abstract addConnectedDevice(device: BleDeviceCommsClass): void;
-    abstract removeConnectedDevice(device: BleDeviceCommsClass): void;
-    abstract findConnected(device: BleDeviceCommsClass | BlePeripheral): BleDeviceCommsClass;
-    abstract getConnector(peripheral: BlePeripheral): BlePeripheralConnector;
-    abstract findPeripheral(peripheral: BlePeripheral | {
-        id?: string;
-        address?: string;
-        name?: string;
-    }): BlePeripheral;
-    getBinding(): BleBinding;
-    setBinding(binding: BleBinding): void;
-}
-export declare enum BleState {
-    UNKNOWN = "unknown",
-    RESETTING = "resetting",
-    UNSUPPORTED = "unsupported",
-    UNAUTHORIZED = "unauthorized",
-    POWERED_OFF = "poweredOff",
-    POWERED_ON = "poweredOn"
-}

package/lib/ble/ble.js

@@ -1,48 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BleState = exports.BleInterfaceClass = exports.BleBindingWrapper = void 0;
-const events_1 = __importDefault(require("events"));
-class BleBindingWrapper {
-    constructor(binding) {
-        this.binding = binding;
-        this.binding = binding;
-    }
-    open() {
-        const binding = this.binding._bindings;
-        const binding_init = binding.init.bind(binding);
-        try {
-            binding_init();
-            return { err: null, opened: true };
-        }
-        catch (err) {
-            const error = err;
-            const opened = false;
-            return { err: error, opened };
-        }
-    }
-    get() {
-        return this.binding;
-    }
-}
-exports.BleBindingWrapper = BleBindingWrapper;
-class BleInterfaceClass extends events_1.default {
-    constructor(props = {}) {
-        super();
-        this.setBinding(props.binding);
-    }
-    getBinding() { return this.binding; }
-    setBinding(binding) { this.binding = binding; }
-}
-exports.BleInterfaceClass = BleInterfaceClass;
-var BleState;
-(function (BleState) {
-    BleState["UNKNOWN"] = "unknown";
-    BleState["RESETTING"] = "resetting";
-    BleState["UNSUPPORTED"] = "unsupported";
-    BleState["UNAUTHORIZED"] = "unauthorized";
-    BleState["POWERED_OFF"] = "poweredOff";
-    BleState["POWERED_ON"] = "poweredOn";
-})(BleState = exports.BleState || (exports.BleState = {}));