incyclist-devices 2.0.37 → 2.1.0

package/lib/base/adpater.js

@@ -12,7 +12,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ControllableDevice = exports.DEFAULT_PROPS = exports.DEFAULT_USER_WEIGHT = exports.DEFAULT_BIKE_WEIGHT = void 0;
+exports.ControllableDevice = exports.NonControllableDevice = exports.DEFAULT_PROPS = exports.DEFAULT_USER_WEIGHT = exports.DEFAULT_BIKE_WEIGHT = void 0;
+const adapter_1 = require("../types/adapter");
 const events_1 = __importDefault(require("events"));
 exports.DEFAULT_BIKE_WEIGHT = 10;
 exports.DEFAULT_USER_WEIGHT = 75;
@@ -30,13 +31,18 @@ class IncyclistDevice extends events_1.default {
         this.started = false;
         this.stopped = false;
         this.paused = false;
+        this.bikeControl = new NonControllableDevice(this, props);
+    }
+    setControl(control) {
+        this.bikeControl = control;
     }
     connect() { throw new Error('not implemented'); }
     close() { throw new Error('not implemented'); }
     check() { throw new Error("Method not implemented."); }
-    getLogger() { return undefined; }
+    getLogger() { return this.logger; }
     isControllable() {
-        return false;
+        var _a;
+        return (_a = this.bikeControl) === null || _a === void 0 ? void 0 : _a.isControllable();
     }
     isEqual(settings) { throw new Error("Method not implemented."); }
     getCapabilities() { return this.capabilities; }
@@ -124,46 +130,96 @@ class IncyclistDevice extends events_1.default {
     hasDataListeners() {
         return this.onDataFn || this.listenerCount('data') > 0;
     }
+    setCyclingMode(mode, settings, sendInitCommands) {
+        var _a;
+        if (this.isControllable())
+            (_a = this.bikeControl) === null || _a === void 0 ? void 0 : _a.setCyclingMode(mode, settings, sendInitCommands);
+    }
+    getSupportedCyclingModes() {
+        var _a;
+        if (!this.isControllable())
+            return [];
+        return (_a = this.bikeControl) === null || _a === void 0 ? void 0 : _a.getSupportedCyclingModes();
+    }
+    getCyclingMode() {
+        if (this.isControllable())
+            return this.bikeControl.getCyclingMode();
+    }
+    getDefaultCyclingMode() {
+        if (this.isControllable())
+            return this.bikeControl.getDefaultCyclingMode();
+    }
+    setBikeProps(props) {
+        if (this.isControllable())
+            this.bikeControl.setBikeProps(props);
+    }
+    setUser(user) {
+        if (this.isControllable())
+            this.bikeControl.setUser(user);
+    }
+    getUser() {
+        var _a;
+        return ((_a = this.bikeControl) === null || _a === void 0 ? void 0 : _a.getUser()) || {};
+    }
+    getWeight() {
+        var _a;
+        return (_a = this.bikeControl) === null || _a === void 0 ? void 0 : _a.getWeight();
+    }
+    sendInitCommands() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.isControllable())
+                return yield this.bikeControl.sendInitCommands();
+            return false;
+        });
+    }
 }
 exports.default = IncyclistDevice;
-class ControllableDevice extends IncyclistDevice {
-    constructor(settings, props) {
-        super(settings, props);
-        this.cyclingMode = this.getDefaultCyclingMode();
-        this.user = {};
-    }
+class NonControllableDevice extends adapter_1.Controllable {
     isControllable() {
-        return true;
+        return false;
     }
-    setUser(user) {
-        this.user = user;
-        if (!user.weight)
-            this.user.weight = exports.DEFAULT_USER_WEIGHT;
+    setCyclingMode(mode, settings, sendInitCommands) {
+        throw new Error("Method not implemented.");
+    }
+    getSupportedCyclingModes() {
+        throw new Error("Method not implemented.");
+    }
+    getCyclingMode() {
+        throw new Error("Method not implemented.");
+    }
+    getDefaultCyclingMode() {
+        throw new Error("Method not implemented.");
     }
     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;
+        throw new Error("Method not implemented.");
+    }
+    setUser(user) {
+        throw new Error("Method not implemented.");
+    }
+    sendInitCommands() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return false;
         });
     }
+}
+exports.NonControllableDevice = NonControllableDevice;
+class ControllableDevice extends adapter_1.Controllable {
+    constructor(adapter, props) {
+        super(adapter, props);
+        this.cyclingMode = this.getDefaultCyclingMode();
+    }
+    isControllable() {
+        return true;
+    }
     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; });
+            const CyclingModeClass = supported.find(M => { const m = new M(this.adapter); return m.getName() === mode; });
             if (CyclingModeClass) {
-                this.cyclingMode = new CyclingModeClass(this, settings);
+                this.cyclingMode = new CyclingModeClass(this.adapter, settings);
                 return;
             }
             selectedMode = this.getDefaultCyclingMode();

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);
@@ -168,10 +178,9 @@ class BleAdapter extends adpater_1.default {
             const wasStopped = this.stopped;
             if (wasPaused)
                 this.resume();
-            if (wasStopped)
-                this.stopped = false;
-            if (this.started && !wasPaused && !wasStopped)
+            if (this.started && !wasStopped)
                 return true;
+            this.stopped = false;
             const connected = yield this.connect();
             if (!connected)
                 throw new Error(`could not start device, reason:could not connect`);
@@ -233,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>;