incyclist-devices 2.0.38 → 2.1.0

package/lib/ble/adapter-factory.d.ts

@@ -1,30 +1,31 @@
 import { DeviceProperties } from "../types/device";
 import BleAdapter from "./base/adapter";
-import { BleDeviceSettings, BleProtocol } from "./types";
+import { BleDeviceProperties, BleDeviceSettings, BleProtocol } from "./types";
 import { BleComms } from "./base/comms";
+import { Controllable } from "../types/adapter";
 export interface BleAdapterInfo {
     protocol: BleProtocol;
-    Adapter: typeof BleAdapter;
+    Adapter: typeof BleAdapter<Controllable<BleDeviceProperties>>;
     Comm: typeof BleComms;
 }
 export default class BleAdapterFactory {
     static _instance: BleAdapterFactory;
     implementations: BleAdapterInfo[];
-    instances: BleAdapter[];
+    instances: Array<BleAdapter<Controllable<BleDeviceProperties>>>;
     static getInstance(): BleAdapterFactory;
     constructor();
     getAdapterInfo(protocol: BleProtocol): BleAdapterInfo;
     getAll(): BleAdapterInfo[];
-    createInstance(settings: BleDeviceSettings, props?: DeviceProperties): BleAdapter;
+    createInstance(settings: BleDeviceSettings, props?: DeviceProperties): BleAdapter<Controllable<BleDeviceProperties>>;
     removeInstance(query: {
         settings?: BleDeviceSettings;
-        adapter?: BleAdapter;
+        adapter?: BleAdapter<Controllable<DeviceProperties>>;
     }): void;
-    find(settings?: BleDeviceSettings): BleAdapter;
-    register(protocol: BleProtocol, Adapter: typeof BleAdapter, Comm: typeof BleComms): void;
-    getAllInstances(): BleAdapter[];
+    find(settings?: BleDeviceSettings): BleAdapter<Controllable<BleDeviceProperties>>;
+    register(protocol: BleProtocol, Adapter: typeof BleAdapter<Controllable<BleDeviceProperties>>, Comm: typeof BleComms): void;
+    getAllInstances(): Array<BleAdapter<Controllable<DeviceProperties>>>;
     getAllSupportedComms(): (typeof BleComms)[];
-    getAllSupportedAdapters(): (typeof BleAdapter)[];
+    getAllSupportedAdapters(): Array<(typeof BleAdapter<Controllable<BleDeviceProperties>>)>;
     getAllSupportedServices(): string[];
     getDeviceClasses(peripheral: any, props?: {
         protocol?: BleProtocol;

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

@@ -1,13 +1,16 @@
-import IncyclistDevice from "../../base/adpater";
-import CyclingMode, { IncyclistBikeData } from "../../modes/cycling-mode";
-import { Bike } from "../../types/adapter";
+import IncyclistDevice, { ControllableDevice } from "../../base/adpater";
+import ICyclingMode, { IncyclistBikeData } from "../../modes/types";
+import { Controllable, IncyclistDeviceAdapter } from "../../types/adapter";
 import { DeviceData } from "../../types/data";
 import { DeviceProperties } from "../../types/device";
-import { User } from "../../types/user";
 import { BleComms } from "./comms";
 import BleInterface from "../ble-interface";
 import { BleDeviceProperties, BleDeviceSettings, BleStartProperties } from "../types";
-export default class BleAdapter extends IncyclistDevice {
+export declare class BlePowerControl extends ControllableDevice<BleDeviceProperties> {
+    getDefaultCyclingMode(): ICyclingMode;
+    getSupportedCyclingModes(): any[];
+}
+export default class BleAdapter<DC extends Controllable<BleDeviceProperties>> extends IncyclistDevice<DC, BleDeviceProperties> {
     ble: BleInterface;
     deviceData: any;
     data: DeviceData;
@@ -20,7 +23,7 @@ export default class BleAdapter extends IncyclistDevice {
     close(): Promise<boolean>;
     getComms(): BleComms;
     isEqual(settings: BleDeviceSettings): boolean;
-    isSame(adapter: BleAdapter): boolean;
+    isSame(adapter: IncyclistDeviceAdapter): boolean;
     isConnected(): boolean;
     resetData(): void;
     getInterface(): string;
@@ -38,17 +41,3 @@ export default class BleAdapter extends IncyclistDevice {
     pause(): Promise<boolean>;
     resume(): Promise<boolean>;
 }
-export declare class BleControllableAdapter extends BleAdapter implements Bike {
-    cyclingMode: CyclingMode;
-    user?: User;
-    constructor(settings: BleDeviceSettings, props?: DeviceProperties);
-    setUser(user: User): void;
-    isControllable(): boolean;
-    setBikeProps(props: DeviceProperties): void;
-    getWeight(): number;
-    getSupportedCyclingModes(): any[];
-    getDefaultCyclingMode(): CyclingMode;
-    setCyclingMode(mode: CyclingMode | string, settings?: any): void;
-    sendInitCommands(): Promise<boolean>;
-    getCyclingMode(): CyclingMode;
-}

package/lib/ble/base/adapter.js

@@ -35,10 +35,20 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BleControllableAdapter = void 0;
+exports.BlePowerControl = void 0;
 const adpater_1 = __importStar(require("../../base/adpater"));
 const ble_interface_1 = __importDefault(require("../ble-interface"));
+const power_meter_1 = __importDefault(require("../../modes/power-meter"));
 const INTERFACE_NAME = 'ble';
+class BlePowerControl extends adpater_1.ControllableDevice {
+    getDefaultCyclingMode() {
+        return new power_meter_1.default(this.adapter);
+    }
+    getSupportedCyclingModes() {
+        return [power_meter_1.default];
+    }
+}
+exports.BlePowerControl = BlePowerControl;
 class BleAdapter extends adpater_1.default {
     constructor(settings, props) {
         super(settings, props);
@@ -136,8 +146,8 @@ class BleAdapter extends adpater_1.default {
         this.deviceData = Object.assign({}, deviceData);
         if (!this.started || !this.canSendUpdate())
             return;
-        this.logEvent({ message: 'onDeviceData', data: deviceData, isControllable: (this instanceof BleControllableAdapter) });
-        if (this instanceof BleControllableAdapter) {
+        this.logEvent({ message: 'onDeviceData', data: deviceData, isControllable: this.isControllable() });
+        if (this.isControllable()) {
             const mappedData = this.mapData(deviceData);
             const incyclistData = this.getCyclingMode().updateData(mappedData);
             this.data = this.transformData(incyclistData);
@@ -232,69 +242,3 @@ class BleAdapter extends adpater_1.default {
     }
 }
 exports.default = BleAdapter;
-class BleControllableAdapter extends BleAdapter {
-    constructor(settings, props) {
-        super(settings, props);
-        this.cyclingMode = this.getDefaultCyclingMode();
-        this.user = {};
-    }
-    setUser(user) {
-        this.user = user;
-        if (!user.weight)
-            this.user.weight = adpater_1.DEFAULT_USER_WEIGHT;
-    }
-    isControllable() {
-        return true;
-    }
-    setBikeProps(props) {
-        const { user, userWeight } = props || {};
-        if (user)
-            this.setUser(user);
-        if (userWeight)
-            this.user.weight = userWeight;
-        const keys = Object.keys(props);
-        keys.forEach(k => {
-            const p = props[k];
-            if (p === null)
-                delete this.props[k];
-            else if (p !== undefined)
-                this.props[k] = p;
-        });
-    }
-    getWeight() {
-        const { user = {}, props = adpater_1.DEFAULT_PROPS } = this;
-        const userWeight = user.weight || props.userWeight || adpater_1.DEFAULT_USER_WEIGHT;
-        const bikeWeight = props.bikeWeight || adpater_1.DEFAULT_BIKE_WEIGHT;
-        return userWeight + bikeWeight;
-    }
-    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.cyclingMode = new CyclingModeClass(this, settings);
-                return;
-            }
-            selectedMode = this.getDefaultCyclingMode();
-        }
-        else {
-            selectedMode = mode;
-        }
-        this.cyclingMode = selectedMode;
-        this.cyclingMode.setSettings(settings);
-    }
-    sendInitCommands() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return true;
-        });
-    }
-    getCyclingMode() {
-        if (!this.cyclingMode)
-            this.setCyclingMode(this.getDefaultCyclingMode());
-        return this.cyclingMode;
-    }
-}
-exports.BleControllableAdapter = BleControllableAdapter;

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

@@ -2,13 +2,14 @@
 /// <reference types="node" />
 import { EventLogger } from 'gd-eventlog';
 import BleAdapterFactory from './adapter-factory';
-import { BleInterfaceProps, BlePeripheral, BleDeviceSettings, BleProtocol, BleBinding, BleInterfaceState, BleScanProps, BleCharacteristic } from './types';
+import { BleInterfaceProps, BlePeripheral, BleDeviceSettings, BleProtocol, BleBinding, BleInterfaceState, BleScanProps, BleCharacteristic, BleDeviceProperties } from './types';
 import { BleComms } from './base/comms';
 import { IncyclistInterface } from '../types/interface';
 import BleAdapter from './base/adapter';
 import { IncyclistScanProps } from '../types/device';
 import BlePeripheralCache from './peripheral-cache';
 import EventEmitter from 'events';
+import { Controllable } from '..';
 export interface ScanState {
     isScanning: boolean;
     isConnecting: boolean;
@@ -40,7 +41,7 @@ export default class BleInterface extends EventEmitter implements IncyclistInter
     logger: EventLogger;
     props: BleInterfaceProps;
     binding: BleBinding;
-    connectedDevices: BleAdapter[];
+    connectedDevices: Array<BleAdapter<Controllable<BleDeviceProperties>>>;
     sensorIsConnecting: boolean;
     emittingAdapters: {
         comms: BleComms;
@@ -79,6 +80,6 @@ export default class BleInterface extends EventEmitter implements IncyclistInter
     scan(props?: BleScanProps): Promise<BleDeviceSettings[]>;
     stopScan(): Promise<boolean>;
     isScanning(): boolean;
-    addConnectedDevice(device: BleAdapter): void;
-    removeConnectedDevice(device: BleAdapter): void;
+    addConnectedDevice(device: BleAdapter<Controllable<BleDeviceProperties>>): void;
+    removeConnectedDevice(device: BleAdapter<Controllable<BleDeviceProperties>>): void;
 }

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

@@ -1,20 +1,17 @@
-import CyclingMode from '../../modes/cycling-mode';
-import { IncyclistBikeData } from '../../modes/cycling-mode';
-import { BleControllableAdapter } from '../base/adapter';
+import { IncyclistBikeData } from '../../modes/types';
+import BleAdapter, { BlePowerControl } from '../base/adapter';
 import { DeviceProperties } from '../../types/device';
 import { PowerData } from './types';
 import { DeviceData } from '../../types/data';
 import { BleDeviceSettings } from '../types';
-import IncyclistDevice from '../../base/adpater';
-export default class PwrAdapter extends BleControllableAdapter {
+import { IncyclistDeviceAdapter } from '../../types/adapter';
+export default class PwrAdapter extends BleAdapter<BlePowerControl> {
     distanceInternal: number;
     constructor(settings: BleDeviceSettings, props?: DeviceProperties);
-    isSame(device: IncyclistDevice): boolean;
+    isSame(device: IncyclistDeviceAdapter): boolean;
     getProfile(): string;
     getName(): string;
     getDisplayName(): string;
-    getDefaultCyclingMode(): CyclingMode;
-    getSupportedCyclingModes(): any[];
     mapData(deviceData: PowerData): IncyclistBikeData;
     transformData(bikeData: IncyclistBikeData): DeviceData;
     sendUpdate(request: any): Promise<void>;

package/lib/ble/cp/adapter.js

@@ -1,4 +1,27 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (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) {
@@ -13,18 +36,17 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const gd_eventlog_1 = require("gd-eventlog");
-const power_meter_1 = __importDefault(require("../../modes/power-meter"));
 const comm_1 = __importDefault(require("./comm"));
-const adapter_1 = require("../base/adapter");
+const adapter_1 = __importStar(require("../base/adapter"));
 const capabilities_1 = require("../../types/capabilities");
-class PwrAdapter extends adapter_1.BleControllableAdapter {
+class PwrAdapter extends adapter_1.default {
     constructor(settings, props) {
         super(settings, props);
         this.distanceInternal = 0;
+        this.setControl(new adapter_1.BlePowerControl(this, props));
         this.logger = new gd_eventlog_1.EventLogger('Ble-CP');
         const { id, address, name } = settings;
         const logger = this.logger;
-        const ble = this.ble;
         this.device = new comm_1.default({ id, address, name, logger });
         this.capabilities = [
             capabilities_1.IncyclistCapability.Power, capabilities_1.IncyclistCapability.Cadence, capabilities_1.IncyclistCapability.Speed
@@ -47,12 +69,6 @@ class PwrAdapter extends adapter_1.BleControllableAdapter {
         const powerStr = power ? ` (${power})` : '';
         return `${name}${powerStr}`;
     }
-    getDefaultCyclingMode() {
-        return new power_meter_1.default(this);
-    }
-    getSupportedCyclingModes() {
-        return [power_meter_1.default];
-    }
     mapData(deviceData) {
         const data = {
             isPedalling: false,

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

@@ -1,16 +1,17 @@
-import BleAdapter, { BleControllableAdapter } from '../base/adapter';
-import CyclingMode, { IncyclistBikeData } from '../../modes/cycling-mode';
+import BleAdapter, { BlePowerControl } from '../base/adapter';
+import ICyclingMode, { IncyclistBikeData } from '../../modes/types';
 import { PowerData } from '../cp';
 import { DeviceProperties } from '../../types/device';
 import { DeviceData } from '../../types/data';
 import { BleDeviceSettings } from '../types';
-export default class BleEliteAdapter extends BleControllableAdapter {
+import { IncyclistDeviceAdapter } from '../../types/adapter';
+export default class BleEliteAdapter extends BleAdapter<BlePowerControl> {
     distanceInternal: number;
     constructor(settings: BleDeviceSettings, props?: DeviceProperties);
-    isSame(device: BleAdapter): boolean;
+    isSame(device: IncyclistDeviceAdapter): boolean;
     getProfile(): string;
     getName(): string;
-    getDefaultCyclingMode(): CyclingMode;
+    getDefaultCyclingMode(): ICyclingMode;
     getSupportedCyclingModes(): any[];
     mapData(deviceData: PowerData): IncyclistBikeData;
     transformData(bikeData: IncyclistBikeData): DeviceData;

package/lib/ble/elite/adapter.js

@@ -1,4 +1,27 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (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) {
@@ -13,14 +36,15 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const gd_eventlog_1 = require("gd-eventlog");
-const adapter_1 = require("../base/adapter");
+const adapter_1 = __importStar(require("../base/adapter"));
 const comms_1 = __importDefault(require("./comms"));
 const power_meter_1 = __importDefault(require("../../modes/power-meter"));
 const capabilities_1 = require("../../types/capabilities");
-class BleEliteAdapter extends adapter_1.BleControllableAdapter {
+class BleEliteAdapter extends adapter_1.default {
     constructor(settings, props) {
         super(settings, props);
         this.distanceInternal = 0;
+        this.setControl(new adapter_1.BlePowerControl(this, props));
         this.logger = new gd_eventlog_1.EventLogger('BLE-Elite');
         const { id, address, name } = settings;
         const logger = this.logger;

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

@@ -1,19 +1,20 @@
-import BleAdapter, { BleControllableAdapter } from '../base/adapter';
-import CyclingMode, { IncyclistBikeData } from '../../modes/cycling-mode';
-import { DeviceProperties } from '../../types/device';
+import BleAdapter from '../base/adapter';
+import ICyclingMode, { CyclingMode, IncyclistBikeData } from '../../modes/types';
 import { IndoorBikeData } from './types';
 import { DeviceData } from '../../types/data';
-import { BleDeviceSettings, BleStartProperties } from '../types';
-export default class BleFmAdapter extends BleControllableAdapter {
+import { BleDeviceProperties, BleDeviceSettings, BleStartProperties } from '../types';
+import { ControllableDevice } from '../../base/adpater';
+import { IncyclistDeviceAdapter } from '../../types/adapter';
+export default class BleFmAdapter extends BleAdapter<ControllableDevice<BleDeviceProperties>> {
     distanceInternal: number;
     connectPromise: Promise<boolean>;
-    constructor(settings: BleDeviceSettings, props?: DeviceProperties);
-    isSame(device: BleAdapter): boolean;
+    constructor(settings: BleDeviceSettings, props?: BleDeviceProperties);
+    isSame(device: IncyclistDeviceAdapter): boolean;
     getProfile(): string;
     getName(): string;
     getDisplayName(): string;
-    getSupportedCyclingModes(): Array<any>;
-    getDefaultCyclingMode(): CyclingMode;
+    getSupportedCyclingModes(): Array<typeof CyclingMode>;
+    getDefaultCyclingMode(): ICyclingMode;
     mapData(deviceData: IndoorBikeData): IncyclistBikeData;
     transformData(bikeData: IncyclistBikeData): DeviceData;
     start(props?: BleStartProperties): Promise<any>;

package/lib/ble/fm/adapter.js

@@ -1,4 +1,27 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (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) {
@@ -14,17 +37,18 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const gd_eventlog_1 = require("gd-eventlog");
 const power_meter_1 = __importDefault(require("../../modes/power-meter"));
-const ble_st_mode_1 = __importDefault(require("../../modes/ble-st-mode"));
-const ble_erg_mode_1 = __importDefault(require("../../modes/ble-erg-mode"));
+const antble_smarttrainer_1 = __importDefault(require("../../modes/antble-smarttrainer"));
+const antble_erg_1 = __importDefault(require("../../modes/antble-erg"));
 const comms_1 = __importDefault(require("./comms"));
-const adapter_1 = require("../base/adapter");
+const adapter_1 = __importStar(require("../base/adapter"));
 const consts_1 = require("./consts");
 const utils_1 = require("../../utils/utils");
 const capabilities_1 = require("../../types/capabilities");
-class BleFmAdapter extends adapter_1.BleControllableAdapter {
+class BleFmAdapter extends adapter_1.default {
     constructor(settings, props) {
         super(settings, props);
         this.distanceInternal = 0;
+        this.setControl(new adapter_1.BlePowerControl(this, props));
         this.logger = new gd_eventlog_1.EventLogger('BLE-FM');
         const { id, address, name } = settings;
         const logger = this.logger;
@@ -54,22 +78,22 @@ class BleFmAdapter extends adapter_1.BleControllableAdapter {
         const modes = [power_meter_1.default];
         const features = (_a = this.getComms()) === null || _a === void 0 ? void 0 : _a.features;
         if (!features)
-            return [power_meter_1.default, ble_st_mode_1.default, ble_erg_mode_1.default];
+            return [power_meter_1.default, antble_smarttrainer_1.default, antble_erg_1.default];
         if (features.setPower === undefined || features.setPower)
-            modes.push(ble_erg_mode_1.default);
+            modes.push(antble_erg_1.default);
         if (features.setSlope === undefined || features.setSlope)
-            modes.push(ble_st_mode_1.default);
+            modes.push(antble_smarttrainer_1.default);
         return modes;
     }
     getDefaultCyclingMode() {
         var _a;
         const features = (_a = this.getComms()) === null || _a === void 0 ? void 0 : _a.features;
         if (!features)
-            return new ble_st_mode_1.default(this);
+            return new antble_smarttrainer_1.default(this);
         if (features.setSlope === undefined || features.setSlope)
-            return new ble_st_mode_1.default(this);
+            return new antble_smarttrainer_1.default(this);
         if (features.setPower === undefined || features.setPower)
-            return new ble_erg_mode_1.default(this);
+            return new antble_erg_1.default(this);
         return new power_meter_1.default(this);
     }
     mapData(deviceData) {
@@ -227,6 +251,9 @@ class BleFmAdapter extends adapter_1.BleControllableAdapter {
                 }
             }
             catch (err) {
+                if (err.message === 'not connected') {
+                    this.logEvent({ message: 'send bike update failed', reason: 'not connected' });
+                }
                 this.logEvent({ message: 'error', fn: 'sendUpdate()', request, error: err.message, stack: err.stack });
             }
         });
@@ -235,7 +262,7 @@ class BleFmAdapter extends adapter_1.BleControllableAdapter {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.started && !this.stopped) {
                 try {
-                    if (this.getCyclingMode() instanceof ble_erg_mode_1.default) {
+                    if (this.getCyclingMode() instanceof antble_erg_1.default) {
                         const power = this.data.power;
                         const request = power ? { targetPower: power } : this.getCyclingMode().getBikeInitRequest();
                         yield this.sendUpdate(request, true);

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

@@ -1,12 +1,14 @@
 import BleAdapter from '../base/adapter';
 import { DeviceProperties } from '../../types/device';
-import { BleDeviceSettings } from '../types';
+import { BleDeviceProperties, BleDeviceSettings } from '../types';
 import { HrmData } from './types';
 import { DeviceData } from '../../types/data';
-export default class HrmAdapter extends BleAdapter {
+import { NonControllableDevice } from '../../base/adpater';
+import { IncyclistDeviceAdapter } from '../../types/adapter';
+export default class HrmAdapter extends BleAdapter<NonControllableDevice<BleDeviceProperties>> {
     ignore: boolean;
     constructor(settings: BleDeviceSettings, props?: DeviceProperties);
-    isSame(device: BleAdapter): boolean;
+    isSame(device: IncyclistDeviceAdapter): boolean;
     getProfile(): string;
     getName(): string;
     getDisplayName(): string;

package/lib/ble/peripheral-cache.d.ts

@@ -1,6 +1,7 @@
+import { Controllable } from "../types/adapter";
 import BleAdapter from "./base/adapter";
 import BlePeripheralConnector from "./ble-peripheral";
-import { BleCharacteristic, BlePeripheral } from "./types";
+import { BleCharacteristic, BleDeviceProperties, BlePeripheral } from "./types";
 export interface PeripheralState {
     isLoading: boolean;
     isConfigured: boolean;
@@ -18,7 +19,7 @@ export interface PeripheralCacheItem {
 }
 export default class BlePeripheralCache {
     peripherals: PeripheralCacheItem[];
-    findAdapter(adapter: BleAdapter): PeripheralCacheItem;
+    findAdapter(adapter: BleAdapter<Controllable<BleDeviceProperties>>): PeripheralCacheItem;
     getConnector(peripheral: BlePeripheral): BlePeripheralConnector;
     getPeripheral(query: {
         id?: string;

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

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

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

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

package/lib/index.d.ts

@@ -2,15 +2,15 @@ import { INTERFACE } from './types/device';
 import InterfaceFactory from './interfaces';
 import AdapterFactory from './adapters';
 import { IncyclistInterface, InterfaceProps } from './types/interface';
-import { IncyclistDeviceAdapter, Bike as Controllable } from './types/adapter';
+import { IncyclistDeviceAdapter, Controllable } from './types/adapter';
 import { ControllableDevice as ControllableDeviceAdapter } from './base/adpater';
 import { IncyclistCapability } from './types/capabilities';
 import { DeviceData } from './types/data';
-import { DeviceSettings } from './types/device';
-import CyclingMode from './modes/cycling-mode';
+import { DeviceSettings, DeviceProperties } from './types/device';
+import ICyclingMode from './modes/types';
 import calc from './utils/calculations';
-export * from './modes/cycling-mode';
+export * from './modes/types';
 export * from './serial';
 export * from './ble';
 export * from './antv2';
-export { IncyclistInterface, INTERFACE, InterfaceFactory, InterfaceProps, DeviceSettings, CyclingMode, AdapterFactory, IncyclistDeviceAdapter, Controllable, ControllableDeviceAdapter, DeviceData, IncyclistCapability, calc, };
+export { IncyclistInterface, INTERFACE, InterfaceFactory, InterfaceProps, DeviceSettings, DeviceProperties, ICyclingMode, AdapterFactory, IncyclistDeviceAdapter, Controllable, ControllableDeviceAdapter, DeviceData, IncyclistCapability, calc, };

package/lib/index.js

@@ -17,20 +17,22 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.calc = exports.IncyclistCapability = exports.ControllableDeviceAdapter = exports.AdapterFactory = exports.InterfaceFactory = exports.INTERFACE = void 0;
+exports.calc = exports.IncyclistCapability = exports.ControllableDeviceAdapter = exports.Controllable = exports.AdapterFactory = exports.InterfaceFactory = exports.INTERFACE = void 0;
 const device_1 = require("./types/device");
 Object.defineProperty(exports, "INTERFACE", { enumerable: true, get: function () { return device_1.INTERFACE; } });
 const interfaces_1 = __importDefault(require("./interfaces"));
 exports.InterfaceFactory = interfaces_1.default;
 const adapters_1 = __importDefault(require("./adapters"));
 exports.AdapterFactory = adapters_1.default;
+const adapter_1 = require("./types/adapter");
+Object.defineProperty(exports, "Controllable", { enumerable: true, get: function () { return adapter_1.Controllable; } });
 const adpater_1 = require("./base/adpater");
 Object.defineProperty(exports, "ControllableDeviceAdapter", { enumerable: true, get: function () { return adpater_1.ControllableDevice; } });
 const capabilities_1 = require("./types/capabilities");
 Object.defineProperty(exports, "IncyclistCapability", { enumerable: true, get: function () { return capabilities_1.IncyclistCapability; } });
 const calculations_1 = __importDefault(require("./utils/calculations"));
 exports.calc = calculations_1.default;
-__exportStar(require("./modes/cycling-mode"), exports);
+__exportStar(require("./modes/types"), exports);
 __exportStar(require("./serial"), exports);
 __exportStar(require("./ble"), exports);
 __exportStar(require("./antv2"), exports);

package/lib/interfaces.d.ts

@@ -3,5 +3,5 @@ import { SerialInterface } from "./serial";
 import AntInterface from "./antv2/ant-interface";
 import { BleInterface } from "./ble";
 export default class InterfaceFactory {
-    static create(ifaceName: string, props?: InterfaceProps): SerialInterface | BleInterface | AntInterface;
+    static create(ifaceName: string, props?: InterfaceProps): AntInterface | SerialInterface | BleInterface;
 }