incyclist-devices 1.5.38 → 2.0.0-beta.1

package/lib/ble/utils.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getServicesFromDevice = exports.getServicesFromDeviceTypes = exports.getDevicesFromServices = exports.getBestDeviceMatch = exports.matches = exports.uuid = void 0;
+function uuid(s) {
+    if (s) {
+        if (s.includes('-')) {
+            const parts = s.split('-');
+            const uuidNo = parseInt('0x' + parts[0]);
+            return uuidNo.toString(16).toLowerCase();
+        }
+        return s;
+    }
+}
+exports.uuid = uuid;
+function matches(uuid1, uuid2) {
+    const ul1 = uuid1.toLowerCase();
+    const ul2 = uuid2.toLowerCase();
+    if (uuid(ul1) === uuid(ul2))
+        return true;
+    if (ul1.length < ul2.length && ul2.startsWith(ul1))
+        return true;
+    if (ul1.length > ul2.length && ul1.startsWith(ul2))
+        return true;
+    return false;
+}
+exports.matches = matches;
+function getBestDeviceMatch(DeviceClasses) {
+    if (!DeviceClasses || DeviceClasses.length === 0)
+        return;
+    const details = DeviceClasses.map(c => ({ name: c.prototype.constructor.name, priority: c.detectionPriority || 0, class: c }));
+    details.sort((a, b) => b.priority - a.priority);
+    return details[0].class;
+}
+exports.getBestDeviceMatch = getBestDeviceMatch;
+function getDevicesFromServices(deviceTypes, services) {
+    if (!deviceTypes || !Array.isArray(deviceTypes) || deviceTypes.length === 0) {
+        return [];
+    }
+    const get = (deviceTypes, fnCompare) => {
+        const types = deviceTypes.filter(DeviceType => {
+            const C = DeviceType;
+            let found = false;
+            if (C.services)
+                found = C.services.find((s) => fnCompare(s));
+            return found;
+        });
+        return types;
+    };
+    if (typeof services === 'string') {
+        return get(deviceTypes, (s) => matches(s, services));
+    }
+    if (Array.isArray(services)) {
+        const sids = services.map(uuid);
+        return get(deviceTypes, s => {
+            const res = sids.find((service) => matches(s, service));
+            return res !== undefined;
+        });
+    }
+    return [];
+}
+exports.getDevicesFromServices = getDevicesFromServices;
+function getServicesFromDeviceTypes(deviceTypes) {
+    let services = [];
+    try {
+        if (!deviceTypes || !Array.isArray(deviceTypes) || deviceTypes.length === 0) {
+            return [];
+        }
+        deviceTypes.forEach(DeviceType => {
+            if (DeviceType.services) {
+                const dtServices = DeviceType.services;
+                dtServices.forEach(s => {
+                    if (!services.find(s2 => s2 === s))
+                        services.push(s);
+                });
+            }
+        });
+    }
+    catch (err) {
+        console.log(err);
+    }
+    return services;
+}
+exports.getServicesFromDeviceTypes = getServicesFromDeviceTypes;
+function getServicesFromDevice(device) {
+    if (!device)
+        return [];
+    const services = [];
+    const dServices = device.getServiceUUids();
+    dServices.forEach(s => {
+        if (!services.find(s2 => s2 === s))
+            services.push(s);
+    });
+    return services;
+}
+exports.getServicesFromDevice = getServicesFromDevice;

package/lib/ble/wahoo/adapter.d.ts

@@ -0,0 +1,9 @@
+import { BleFmAdapter } from '../fm';
+import BleAdapter from '../adapter';
+import { BleDeviceProperties, BleDeviceSettings, BleStartProperties } from '../types';
+export default class BleWahooAdapter extends BleFmAdapter {
+    constructor(settings: BleDeviceSettings, props?: BleDeviceProperties);
+    isSame(device: BleAdapter): boolean;
+    getProfile(): string;
+    start(props?: BleStartProperties): Promise<any>;
+}

package/lib/ble/wahoo/adapter.js

@@ -0,0 +1,93 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const gd_eventlog_1 = require("gd-eventlog");
+const fm_1 = require("../fm");
+const comms_1 = __importDefault(require("./comms"));
+const adpater_1 = require("../../base/adpater");
+const capabilities_1 = require("../../types/capabilities");
+class BleWahooAdapter extends fm_1.BleFmAdapter {
+    constructor(settings, props) {
+        super(settings, props);
+        this.logger = new gd_eventlog_1.EventLogger('BLE-WahooFM');
+        const { id, address, name } = settings;
+        const logger = this.logger;
+        const ble = this.ble;
+        this.device = new comms_1.default({ id, address, name, ble, logger });
+        this.capabilities = [
+            capabilities_1.IncyclistCapability.Power, capabilities_1.IncyclistCapability.Speed, capabilities_1.IncyclistCapability.Cadence,
+            capabilities_1.IncyclistCapability.Control
+        ];
+    }
+    isSame(device) {
+        if (!(device instanceof BleWahooAdapter))
+            return false;
+        return this.isEqual(device.settings);
+    }
+    getProfile() {
+        return 'Smart Trainer';
+    }
+    start(props = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.logger.logEvent({ message: 'start requested', protocol: this.getProtocolName(), props });
+            try {
+                if (this.ble.isScanning()) {
+                    this.logger.logEvent({ message: 'stop previous scan', isScanning: this.ble.isScanning() });
+                    yield this.ble.stopScan();
+                }
+                const bleDevice = yield this.ble.connectDevice(this.device);
+                if (bleDevice) {
+                    this.device = bleDevice;
+                    const mode = this.getCyclingMode();
+                    if (mode && mode.getSetting('bikeType')) {
+                        const bikeType = mode.getSetting('bikeType').toLowerCase();
+                        bleDevice.setCrr(fm_1.cRR);
+                        switch (bikeType) {
+                            case 'race':
+                                bleDevice.setCw(fm_1.cwABike.race);
+                                break;
+                            case 'triathlon':
+                                bleDevice.setCw(fm_1.cwABike.triathlon);
+                                break;
+                            case 'mountain':
+                                bleDevice.setCw(fm_1.cwABike.mountain);
+                                break;
+                        }
+                    }
+                    const { user, bikeWeight = adpater_1.DEFAULT_BIKE_WEIGHT } = props || {};
+                    const weight = (user && user.weight ? Number(user.weight) : adpater_1.DEFAULT_USER_WEIGHT) + bikeWeight;
+                    yield bleDevice.setSimMode(weight, bleDevice.getCrr(), bleDevice.getCw());
+                    const startRequest = this.getCyclingMode().getBikeInitRequest();
+                    yield this.sendUpdate(startRequest);
+                    bleDevice.on('data', (data) => {
+                        this.onDeviceData(data);
+                    });
+                    if (bleDevice.isHrm() && !this.hasCapability(capabilities_1.IncyclistCapability.HeartRate)) {
+                        this.capabilities.push(capabilities_1.IncyclistCapability.HeartRate);
+                    }
+                    this.resetData();
+                    this.stopped = false;
+                    this.started = true;
+                    this.paused = false;
+                    return true;
+                }
+            }
+            catch (err) {
+                this.logger.logEvent({ message: 'start result: error', error: err.message, profile: this.getProfile() });
+                throw new Error(`could not start device, reason:${err.message}`);
+            }
+        });
+    }
+}
+exports.default = BleWahooAdapter;

package/lib/ble/{wahoo-kickr.d.ts → wahoo/comms.d.ts}

@@ -1,8 +1,8 @@
 /// <reference types="node" />
-import BleProtocol from './incyclist-protocol';
-import { BleDeviceClass, BleWriteProps } from './ble';
-import DeviceAdapter from '../device';
-import BleFitnessMachineDevice, { FmAdapter } from './fm';
+import { CrankData } from "../cp";
+import { IndoorBikeData } from "../fm";
+import BleFitnessMachineDevice from "../fm/comms";
+import { BleWriteProps } from "../types";
 export declare const enum OpCode {
     unlock = 32,
     setResistanceMode = 64,
@@ -15,31 +15,7 @@ export declare const enum OpCode {
     setSimWindSpeed = 71,
     setWheelCircumference = 72
 }
-declare type IndoorBikeData = {
-    speed?: number;
-    averageSpeed?: number;
-    cadence?: number;
-    averageCadence?: number;
-    totalDistance?: number;
-    resistanceLevel?: number;
-    instantaneousPower?: number;
-    averagePower?: number;
-    expendedEnergy?: number;
-    heartrate?: number;
-    metabolicEquivalent?: number;
-    time?: number;
-    remainingTime?: number;
-    raw?: string;
-    targetPower?: number;
-    targetInclination?: number;
-    status?: string;
-};
-declare type CrankData = {
-    revolutions?: number;
-    time?: number;
-    cntUpdateMissing?: number;
-};
-export default class WahooAdvancedFitnessMachineDevice extends BleFitnessMachineDevice {
+export default class BleWahooDevice extends BleFitnessMachineDevice {
     static services: string[];
     static characteristics: string[];
     static detectionPriority: number;
@@ -86,13 +62,3 @@ export default class WahooAdvancedFitnessMachineDevice extends BleFitnessMachine
     setSlope(slope: any): Promise<boolean>;
     reset(): void;
 }
-export declare class WahooAdvancedFmAdapter extends FmAdapter {
-    device: WahooAdvancedFitnessMachineDevice;
-    constructor(device: BleDeviceClass, protocol: BleProtocol);
-    isSame(device: DeviceAdapter): boolean;
-    getProfile(): string;
-    start(props?: any): Promise<any>;
-    pause(): Promise<boolean>;
-    resume(): Promise<boolean>;
-}
-export {};

package/lib/ble/{wahoo-kickr.js → wahoo/comms.js}

@@ -1,23 +1,4 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -31,22 +12,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.WahooAdvancedFmAdapter = void 0;
-const ble_interface_1 = __importDefault(require("./ble-interface"));
-const ble_1 = require("./ble");
-const device_1 = require("../device");
-const gd_eventlog_1 = require("gd-eventlog");
-const fm_1 = __importStar(require("./fm"));
-const consts_1 = require("./consts");
-const WAHOO_ADVANCED_FTMS = 'a026ee0b';
-const cwABike = {
-    race: 0.35,
-    triathlon: 0.29,
-    mountain: 0.57
-};
-const cRR = 0.0036;
+const adpater_1 = require("../../base/adpater");
+const consts_1 = require("../consts");
+const comms_1 = __importDefault(require("../fm/comms"));
+const utils_1 = require("../utils");
 const ErgWriteDelay = 2000;
-class WahooAdvancedFitnessMachineDevice extends fm_1.default {
+class BleWahooDevice extends comms_1.default {
     constructor(props) {
         super(props);
         this.prevCrankData = undefined;
@@ -55,15 +26,15 @@ class WahooAdvancedFitnessMachineDevice extends fm_1.default {
         this.tsPrevWrite = undefined;
         this.prevSlope = undefined;
         this.isRequestControlBusy = false;
-        this.weight = device_1.DEFAULT_BIKE_WEIGHT + device_1.DEFAULT_USER_WEIGHT;
+        this.weight = adpater_1.DEFAULT_BIKE_WEIGHT + adpater_1.DEFAULT_USER_WEIGHT;
         this.data = {};
         this.wahooCP = consts_1.WAHOO_ADVANCED_TRAINER_CP;
     }
     isMatching(characteristics) {
         if (!characteristics)
             return false;
-        const hasWahooCP = characteristics.find(c => (0, ble_1.matches)(c, consts_1.WAHOO_ADVANCED_TRAINER_CP)) !== undefined;
-        const hasFTMS = characteristics.find(c => (0, ble_1.matches)(c, consts_1.FTMS_CP)) !== undefined;
+        const hasWahooCP = characteristics.find(c => (0, utils_1.matches)(c, consts_1.WAHOO_ADVANCED_TRAINER_CP)) !== undefined;
+        const hasFTMS = characteristics.find(c => (0, utils_1.matches)(c, consts_1.FTMS_CP)) !== undefined;
         return hasWahooCP && !hasFTMS;
     }
     init() {
@@ -91,7 +62,7 @@ class WahooAdvancedFitnessMachineDevice extends fm_1.default {
     setCharacteristicUUIDs(uuids) {
         this.logEvent({ message: 'set uuids', uuids });
         uuids.forEach(c => {
-            if ((0, ble_1.matches)(c, consts_1.WAHOO_ADVANCED_TRAINER_CP))
+            if ((0, utils_1.matches)(c, consts_1.WAHOO_ADVANCED_TRAINER_CP))
                 this.wahooCP = c;
         });
     }
@@ -99,7 +70,7 @@ class WahooAdvancedFitnessMachineDevice extends fm_1.default {
         return 'Wahoo Smart Trainer';
     }
     getServiceUUids() {
-        return WahooAdvancedFitnessMachineDevice.services;
+        return BleWahooDevice.services;
     }
     isBike() {
         return true;
@@ -423,76 +394,7 @@ class WahooAdvancedFitnessMachineDevice extends fm_1.default {
         this.simModeSettings = undefined;
     }
 }
-exports.default = WahooAdvancedFitnessMachineDevice;
-WahooAdvancedFitnessMachineDevice.services = [consts_1.CSP];
-WahooAdvancedFitnessMachineDevice.characteristics = ['2acc', '2ad2', '2ad6', '2ad8', '2ad9', '2ada', consts_1.WAHOO_ADVANCED_TRAINER_CP];
-WahooAdvancedFitnessMachineDevice.detectionPriority = 5;
-ble_interface_1.default.register('WahooAdvancedFitnessMachineDevice', 'wahoo-fm', WahooAdvancedFitnessMachineDevice, WahooAdvancedFitnessMachineDevice.services);
-class WahooAdvancedFmAdapter extends fm_1.FmAdapter {
-    constructor(device, protocol) {
-        super(device, protocol);
-        this.device = device;
-        this.ble = protocol.ble;
-        this.cyclingMode = this.getDefaultCyclingMode();
-        this.logger = new gd_eventlog_1.EventLogger('BLE-WahooFM');
-        if (this.device)
-            this.device.setLogger(this.logger);
-    }
-    isSame(device) {
-        if (!(device instanceof WahooAdvancedFmAdapter))
-            return false;
-        const adapter = device;
-        return (adapter.getName() === this.getName() && adapter.getProfile() === this.getProfile());
-    }
-    getProfile() {
-        return 'Wahoo Smart Trainer';
-    }
-    start(props) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.logger.logEvent({ message: 'wahoo: start requested', profile: this.getProfile(), props, isScanning: this.ble.isScanning() });
-            try {
-                this.logger.logEvent({ message: 'wahoo: stop previous scan', isScanning: this.ble.isScanning() });
-                if (this.ble.isScanning())
-                    yield this.ble.stopScan();
-                this.logger.logEvent({ message: 'wahoo trying device connect' });
-                const bleDevice = yield this.ble.connectDevice(this.device);
-                this.logger.logEvent({ message: 'wahoo device connected', connected: (bleDevice !== null && bleDevice !== undefined) });
-                if (bleDevice) {
-                    this.device = bleDevice;
-                    const mode = this.getCyclingMode();
-                    if (mode && mode.getSetting('bikeType')) {
-                        const bikeType = mode.getSetting('bikeType').toLowerCase();
-                        this.device.setCrr(cRR);
-                        switch (bikeType) {
-                            case 'race':
-                                this.device.setCw(cwABike.race);
-                                break;
-                            case 'triathlon':
-                                this.device.setCw(cwABike.triathlon);
-                                break;
-                            case 'mountain':
-                                this.device.setCw(cwABike.mountain);
-                                break;
-                        }
-                    }
-                    const { user } = props || {};
-                    const weight = (user && user.weight ? Number(user.weight) : device_1.DEFAULT_USER_WEIGHT) + device_1.DEFAULT_BIKE_WEIGHT;
-                    yield this.device.setSimMode(weight, this.device.getCrr(), this.device.getCw());
-                    const startRequest = this.getCyclingMode().getBikeInitRequest();
-                    yield this.sendUpdate(startRequest);
-                    bleDevice.on('data', (data) => {
-                        this.onDeviceData(data);
-                    });
-                    return true;
-                }
-            }
-            catch (err) {
-                this.logger.logEvent({ message: 'start result: error', error: err.message, profile: this.getProfile() });
-                throw new Error(`could not start device, reason:${err.message}`);
-            }
-        });
-    }
-    pause() { this.paused = true; return Promise.resolve(true); }
-    resume() { this.paused = false; return Promise.resolve(true); }
-}
-exports.WahooAdvancedFmAdapter = WahooAdvancedFmAdapter;
+exports.default = BleWahooDevice;
+BleWahooDevice.services = [consts_1.CSP];
+BleWahooDevice.characteristics = ['2acc', '2ad2', '2ad6', '2ad8', '2ad9', '2ada', consts_1.WAHOO_ADVANCED_TRAINER_CP];
+BleWahooDevice.detectionPriority = 5;

package/lib/ble/wahoo/index.d.ts

@@ -0,0 +1,4 @@
+import BleWahooComms from "./comms";
+import BleWahooAdapter from "./adapter";
+import { IndoorBikeData as WahooIndoorBikeData } from "./types";
+export { WahooIndoorBikeData, BleWahooAdapter, BleWahooComms };

package/lib/ble/wahoo/index.js

@@ -0,0 +1,10 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BleWahooComms = exports.BleWahooAdapter = void 0;
+const comms_1 = __importDefault(require("./comms"));
+exports.BleWahooComms = comms_1.default;
+const adapter_1 = __importDefault(require("./adapter"));
+exports.BleWahooAdapter = adapter_1.default;

package/lib/ble/wahoo/types.d.ts

@@ -0,0 +1,19 @@
+export type IndoorBikeData = {
+    speed?: number;
+    averageSpeed?: number;
+    cadence?: number;
+    averageCadence?: number;
+    totalDistance?: number;
+    resistanceLevel?: number;
+    instantaneousPower?: number;
+    averagePower?: number;
+    expendedEnergy?: number;
+    heartrate?: number;
+    metabolicEquivalent?: number;
+    time?: number;
+    remainingTime?: number;
+    raw?: string;
+    targetPower?: number;
+    targetInclination?: number;
+    status?: string;
+};

package/lib/ble/wahoo/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/device.d.ts

@@ -1,94 +0,0 @@
-/// <reference types="node" />
-import { DeviceProtocol, Device } from './protocol';
-import CyclingMode from './cycling-mode';
-import EventEmitter from 'events';
-export declare const DEFAULT_BIKE_WEIGHT = 10;
-export declare const DEFAULT_USER_WEIGHT = 75;
-export declare type DeviceData = {
-    speed?: number;
-    slope?: number;
-    power?: number;
-    cadence?: number;
-    heartrate?: number;
-    distance?: number;
-    timestamp?: number;
-    deviceTime?: number;
-    deviceDistanceCounter?: number;
-    internalDistanceCounter?: number;
-};
-export declare type OnDeviceDataCallback = (data: DeviceData) => void;
-export declare type OnDeviceStartCallback = (completed: number, total: number) => void;
-export interface Bike {
-    setCyclingMode(mode: CyclingMode | string, settings?: any): void;
-    getSupportedCyclingModes(): Array<any>;
-    getCyclingMode(): CyclingMode;
-    getDefaultCyclingMode(): CyclingMode;
-    setUserSettings(userSettings: any): void;
-    setBikeSettings(bikeSettings: any): void;
-}
-export interface DeviceAdapter extends Device {
-    isBike(): boolean;
-    isPower(): boolean;
-    isHrm(): boolean;
-    isSame(device: DeviceAdapter): boolean;
-    getID(): string;
-    getDisplayName(): string;
-    getName(): string;
-    getPort(): string;
-    getProtocol(): DeviceProtocol;
-    getProtocolName(): string;
-    setIgnoreHrm(ignore: boolean): void;
-    setIgnorePower(ignore: boolean): void;
-    setIgnoreBike(ignore: boolean): void;
-    select(): void;
-    unselect(): void;
-    isSelected(): boolean;
-    setDetected(detected?: boolean): void;
-    isDetected(): boolean;
-    start(props?: any): Promise<any>;
-    stop(): Promise<boolean>;
-    pause(): Promise<boolean>;
-    resume(): Promise<boolean>;
-    sendUpdate(request: any): void;
-    onData(callback: OnDeviceDataCallback): void;
-}
-export default class IncyclistDevice extends EventEmitter implements DeviceAdapter {
-    protocol: DeviceProtocol;
-    detected: boolean;
-    selected: boolean;
-    onDataFn: OnDeviceDataCallback;
-    settings: any;
-    constructor(proto: DeviceProtocol, settings?: any);
-    isBike(): boolean;
-    isPower(): boolean;
-    isHrm(): boolean;
-    isSame(device: DeviceAdapter): boolean;
-    getID(): string;
-    getDisplayName(): string;
-    getName(): string;
-    getPort(): string;
-    getProtocol(): DeviceProtocol;
-    getProtocolName(): string;
-    getSupportedCyclingModes(): any[];
-    getDefaultCyclingMode(): CyclingMode;
-    setCyclingMode(mode: CyclingMode | string, settings?: any): void;
-    getCyclingMode(): CyclingMode;
-    setIgnoreHrm(ignore: any): void;
-    setIgnorePower(ignore: any): void;
-    setIgnoreBike(ignore: any): void;
-    select(): void;
-    unselect(): void;
-    isSelected(): boolean;
-    setDetected(detected?: boolean): void;
-    isDetected(): boolean;
-    update(): void;
-    check(): void;
-    connect(): void;
-    close(): void;
-    start(props?: any): Promise<any>;
-    stop(): Promise<boolean>;
-    pause(): Promise<boolean>;
-    resume(): Promise<boolean>;
-    sendUpdate(request: any): void;
-    onData(callback: OnDeviceDataCallback): void;
-}

package/lib/device.js

@@ -1,76 +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.DEFAULT_USER_WEIGHT = exports.DEFAULT_BIKE_WEIGHT = void 0;
-const events_1 = __importDefault(require("events"));
-exports.DEFAULT_BIKE_WEIGHT = 10;
-exports.DEFAULT_USER_WEIGHT = 75;
-class IncyclistDevice extends events_1.default {
-    constructor(proto, settings) {
-        super();
-        this.protocol = proto;
-        this.detected = false;
-        this.selected = false;
-        this.onDataFn = undefined;
-        this.settings = settings || {};
-    }
-    isBike() { throw new Error('not implemented'); }
-    isPower() { throw new Error('not implemented'); }
-    isHrm() { throw new Error('not implemented'); }
-    isSame(device) { throw new Error('not implemented'); }
-    getID() { throw new Error('not implemented'); }
-    getDisplayName() { return this.getName(); }
-    getName() { throw new Error('not implemented'); }
-    getPort() { throw new Error('not implemented'); }
-    getProtocol() { return this.protocol; }
-    getProtocolName() {
-        return this.protocol ? this.protocol.getName() : undefined;
-    }
-    getSupportedCyclingModes() { throw new Error('not implemented'); }
-    getDefaultCyclingMode() { throw new Error('not implemented'); }
-    setCyclingMode(mode, settings) {
-        let selectedMode;
-        if (typeof mode === 'string') {
-            const supported = this.getSupportedCyclingModes();
-            const CyclingModeClass = supported.find(M => { const m = new M(this); return m.getName() === mode; });
-            if (CyclingModeClass) {
-                this.settings.cyclingMode = new CyclingModeClass(this, settings);
-                return;
-            }
-            selectedMode = this.getDefaultCyclingMode();
-        }
-        else {
-            selectedMode = mode;
-        }
-        this.settings.cyclingMode = selectedMode;
-        this.settings.cyclingMode.setSettings(settings);
-    }
-    getCyclingMode() {
-        if (!this.settings.cyclingMode)
-            this.setCyclingMode(this.getDefaultCyclingMode());
-        return this.settings.cyclingMode;
-    }
-    setIgnoreHrm(ignore) { }
-    setIgnorePower(ignore) { }
-    setIgnoreBike(ignore) { }
-    select() { this.selected = true; }
-    unselect() { this.selected = false; }
-    isSelected() { return this.selected; }
-    setDetected(detected = true) { this.detected = detected; }
-    isDetected() { return this.detected; }
-    update() { }
-    check() { }
-    connect() { }
-    close() { }
-    start(props) { throw new Error('not implemented'); }
-    stop() { throw new Error('not implemented'); }
-    pause() { throw new Error('not implemented'); }
-    resume() { throw new Error('not implemented'); }
-    sendUpdate(request) { }
-    onData(callback) {
-        this.onDataFn = callback;
-    }
-}
-exports.default = IncyclistDevice;

package/lib/index.d.ts

@@ -0,0 +1,12 @@
+import { INTERFACE } from './types/device';
+import InterfaceFactory from './interfaces';
+import AdapterFactory from './adapters';
+import { IncyclistInterface } from './types/interface';
+import { IncyclistDeviceAdapter } from './types/adapter';
+import { IncyclistCapability } from './types/capabilities';
+import { DeviceData } from './types/data';
+import { SerialPortProvider, useSerialPortProvider, SerialInterface, TCPBinding, DaumPremiumAdapter, DaumClassicAdapter, KettlerRacerAdapter } from './serial';
+import { AntAdapterFactory, AntFEAdapter, AntHrAdapter, AntPwrAdapter, AntDeviceSettings, AntScanProps, AntInterface } from './antv2';
+import { BleAdapterFactory, BleInterface, BleHrmAdapter, BlePwrAdapter, BleFmAdapter, BleWahooAdapter, BleTacxAdapter } from './ble';
+import { CyclingModeProperyType } from './modes/cycling-mode';
+export { IncyclistInterface, INTERFACE, InterfaceFactory, AdapterFactory, IncyclistDeviceAdapter, DeviceData, IncyclistCapability, AntAdapterFactory, AntFEAdapter, AntHrAdapter, AntPwrAdapter, AntDeviceSettings, AntScanProps, AntInterface, CyclingModeProperyType, BleAdapterFactory, BleInterface, BleHrmAdapter, BlePwrAdapter, BleFmAdapter, BleWahooAdapter, BleTacxAdapter, SerialPortProvider, useSerialPortProvider, SerialInterface, TCPBinding, DaumClassicAdapter, DaumPremiumAdapter, KettlerRacerAdapter };