incyclist-devices 2.0.38 → 2.1.1

package/lib/base/adpater.js

@@ -12,14 +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;
 const events_1 = __importDefault(require("events"));
-exports.DEFAULT_BIKE_WEIGHT = 10;
-exports.DEFAULT_USER_WEIGHT = 75;
-exports.DEFAULT_PROPS = {
-    userWeight: exports.DEFAULT_USER_WEIGHT,
-    bikeWeight: exports.DEFAULT_BIKE_WEIGHT
-};
+const consts_1 = require("./consts");
 class IncyclistDevice extends events_1.default {
     constructor(settings, props) {
         super();
@@ -30,24 +24,40 @@ class IncyclistDevice extends events_1.default {
         this.started = false;
         this.stopped = false;
         this.paused = false;
+        this.user = {};
+        this.data = {};
+        this.cyclingMode = this.getDefaultCyclingMode();
     }
-    connect() { throw new Error('not implemented'); }
-    close() { throw new Error('not implemented'); }
-    check() { throw new Error("Method not implemented."); }
-    getLogger() { return undefined; }
-    isControllable() {
-        return false;
+    getLogger() { return this.logger; }
+    logEvent(event) {
+        if (!this.logger || this.paused)
+            return;
+        this.logger.logEvent(event);
+        const w = global.window;
+        if ((w === null || w === void 0 ? void 0 : w.DEVICE_DEBUG) || process.env.BLE_DEBUG || process.env.ANT_DEBUG) {
+            const logText = `~~~ ${this.getInterface()}: ${this.logger.getName()}`;
+            console.log(logText, event);
+        }
     }
-    isEqual(settings) { throw new Error("Method not implemented."); }
-    getCapabilities() { return this.capabilities; }
-    hasCapability(capability) {
-        return this.capabilities.find(c => c === capability) !== undefined;
+    getName() {
+        return this.settings.name;
     }
-    addCapability(capability) {
-        if (!this.capabilities.includes(capability))
-            this.capabilities.push(capability);
+    getID() { throw new Error('not implemented'); }
+    getUniqueName() {
+        throw new Error("Method not implemented.");
     }
-    update() { throw new Error("Method not implemented."); }
+    getDisplayName() {
+        return this.getName();
+    }
+    getSettings() {
+        return this.settings;
+    }
+    isSame(adapter) { throw new Error("Method not implemented."); }
+    isEqual(settings) { throw new Error("Method not implemented."); }
+    getInterface() {
+        return typeof this.settings.interface === 'string' ? this.settings.interface : this.settings.interface.getName();
+    }
+    check() { throw new Error("Method not implemented."); }
     start(props) { throw new Error("Method not implemented."); }
     stop() { throw new Error("Method not implemented."); }
     pause() {
@@ -62,15 +72,32 @@ class IncyclistDevice extends events_1.default {
             return true;
         });
     }
-    logEvent(event) {
-        if (!this.logger || this.paused)
-            return;
-        this.logger.logEvent(event);
-        const w = global.window;
-        if ((w === null || w === void 0 ? void 0 : w.DEVICE_DEBUG) || process.env.BLE_DEBUG || process.env.ANT_DEBUG) {
-            const logText = '~~~ ' + this.logger.getName();
-            console.log(logText, event);
+    connect() { throw new Error('not implemented'); }
+    close() { throw new Error('not implemented'); }
+    getControllerInfo() {
+        const a = this.constructor;
+        const config = a.controllers;
+        if (!config)
+            return undefined;
+        if (config.modes && config.modes.length > 0) {
+            if (!config.default)
+                config.default = config.modes[0];
+            return config;
         }
+        return undefined;
+    }
+    isControllable() {
+        if (!this.getControllerInfo())
+            return false;
+        return true;
+    }
+    getCapabilities() { return this.capabilities; }
+    hasCapability(capability) {
+        return this.capabilities.find(c => c === capability) !== undefined;
+    }
+    addCapability(capability) {
+        if (!this.capabilities.includes(capability))
+            this.capabilities.push(capability);
     }
     getMaxUpdateFrequency() {
         return this.updateFrequency;
@@ -78,34 +105,100 @@ class IncyclistDevice extends events_1.default {
     setMaxUpdateFrequency(value) {
         this.updateFrequency = value;
     }
-    sendUpdate(request) { throw new Error("Method not implemented."); }
-    getID() { throw new Error('not implemented'); }
-    getDisplayName() {
-        return this.getName();
+    update() { throw new Error("Method not implemented."); }
+    setCyclingMode(mode, settings, sendInitCommands) {
+        if (!this.isControllable())
+            return;
+        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);
     }
-    getName() {
-        return this.settings.name;
+    getSupportedCyclingModes() {
+        if (!this.isControllable())
+            return [];
+        const config = this.getControllerInfo();
+        return config.modes;
     }
-    getUniqueName() {
+    getCyclingMode() {
+        if (this.isControllable())
+            return this.cyclingMode;
+    }
+    getDefaultCyclingMode() {
+        if (!this.isControllable())
+            return;
+        const config = this.getControllerInfo();
+        const C = config.default;
+        try {
+            return new C(this);
+        }
+        catch (err) {
+            this.logEvent({ message: 'error', error: err.message, fn: 'getDefaultCyclingMode', stack: err.stack });
+        }
+    }
+    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;
+        });
+    }
+    sendInitCommands() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return false;
+        });
+    }
+    sendUpdate(request) {
+        if (!this.isControllable())
+            return;
         throw new Error("Method not implemented.");
     }
-    getSettings() {
-        return this.settings;
+    setUser(user) {
+        this.user = user;
+        if (!user.weight)
+            this.user.weight = consts_1.DEFAULT_USER_WEIGHT;
     }
-    getInterface() {
-        return typeof this.settings.interface === 'string' ? this.settings.interface : this.settings.interface.getName();
+    getUser() {
+        return this.user;
     }
-    onData(callback) {
-        this.onDataFn = callback;
+    getWeight() {
+        const { user = {}, props = consts_1.DEFAULT_PROPS } = this;
+        const userWeight = user.weight || props.userWeight || consts_1.DEFAULT_USER_WEIGHT;
+        const bikeWeight = props.bikeWeight || consts_1.DEFAULT_BIKE_WEIGHT;
+        return userWeight + bikeWeight;
     }
-    canSendUpdate() {
+    isUpdateWithinFrequency() {
         const updateFrequency = this.getMaxUpdateFrequency();
         if (updateFrequency === -1 || updateFrequency === undefined)
             return true;
         return (!this.lastUpdate || (Date.now() - this.lastUpdate) > updateFrequency);
     }
+    canEmitData() {
+        if (this.paused || this.stopped)
+            return false;
+        return this.isUpdateWithinFrequency();
+    }
     emitData(data) {
-        if (!this.canSendUpdate())
+        if (!this.canEmitData())
             return;
         if (this.onDataFn)
             this.onDataFn(data);
@@ -121,74 +214,15 @@ class IncyclistDevice extends events_1.default {
     isPaused() {
         return this.paused;
     }
+    getData() {
+        return this.data;
+    }
     hasDataListeners() {
         return this.onDataFn || this.listenerCount('data') > 0;
     }
-}
-exports.default = IncyclistDevice;
-class ControllableDevice extends IncyclistDevice {
-    constructor(settings, props) {
-        super(settings, props);
-        this.cyclingMode = this.getDefaultCyclingMode();
-        this.user = {};
-    }
-    isControllable() {
-        return true;
-    }
-    setUser(user) {
-        this.user = user;
-        if (!user.weight)
-            this.user.weight = exports.DEFAULT_USER_WEIGHT;
-    }
-    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;
-        });
-    }
-    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;
-    }
-    getWeight() {
-        const { user = {}, props = exports.DEFAULT_PROPS } = this;
-        const userWeight = user.weight || props.userWeight || exports.DEFAULT_USER_WEIGHT;
-        const bikeWeight = props.bikeWeight || exports.DEFAULT_BIKE_WEIGHT;
-        return userWeight + bikeWeight;
+    onData(callback) {
+        this.onDataFn = callback;
     }
 }
-exports.ControllableDevice = ControllableDevice;
+IncyclistDevice.controllers = {};
+exports.default = IncyclistDevice;

package/lib/base/consts.d.ts

@@ -0,0 +1,4 @@
+import { DeviceProperties } from "../types";
+export declare const DEFAULT_BIKE_WEIGHT = 10;
+export declare const DEFAULT_USER_WEIGHT = 75;
+export declare const DEFAULT_PROPS: DeviceProperties;

package/lib/base/consts.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_PROPS = exports.DEFAULT_USER_WEIGHT = exports.DEFAULT_BIKE_WEIGHT = void 0;
+exports.DEFAULT_BIKE_WEIGHT = 10;
+exports.DEFAULT_USER_WEIGHT = 75;
+exports.DEFAULT_PROPS = {
+    userWeight: exports.DEFAULT_USER_WEIGHT,
+    bikeWeight: exports.DEFAULT_BIKE_WEIGHT
+};

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

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

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

@@ -1,16 +1,12 @@
 import IncyclistDevice from "../../base/adpater";
-import CyclingMode, { IncyclistBikeData } 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 "./comms";
 import BleInterface from "../ble-interface";
 import { BleDeviceProperties, BleDeviceSettings, BleStartProperties } from "../types";
-export default class BleAdapter extends IncyclistDevice {
+import { IAdapter, IncyclistBikeData, IncyclistAdapterData, DeviceProperties } from "../../types";
+export default class BleAdapter extends IncyclistDevice<BleDeviceProperties> {
     ble: BleInterface;
     deviceData: any;
-    data: DeviceData;
+    data: IncyclistAdapterData;
     dataMsgCount: number;
     lastDataTS: number;
     device: BleComms;
@@ -20,7 +16,7 @@ export default class BleAdapter extends IncyclistDevice {
     close(): Promise<boolean>;
     getComms(): BleComms;
     isEqual(settings: BleDeviceSettings): boolean;
-    isSame(adapter: BleAdapter): boolean;
+    isSame(adapter: IAdapter): boolean;
     isConnected(): boolean;
     resetData(): void;
     getInterface(): string;
@@ -28,8 +24,8 @@ export default class BleAdapter extends IncyclistDevice {
     getID(): string;
     getName(): string;
     onDeviceData(deviceData: any): void;
-    mapData(deviceData: any): DeviceData | IncyclistBikeData;
-    transformData(data: IncyclistBikeData): DeviceData;
+    mapData(deviceData: any): IncyclistAdapterData | IncyclistBikeData;
+    transformData(data: IncyclistBikeData): IncyclistAdapterData;
     getSettings(): BleDeviceSettings;
     setProperties(props: BleDeviceProperties): void;
     check(): Promise<boolean>;
@@ -38,17 +34,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

@@ -1,27 +1,4 @@
 "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) {
@@ -35,8 +12,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BleControllableAdapter = void 0;
-const adpater_1 = __importStar(require("../../base/adpater"));
+const adpater_1 = __importDefault(require("../../base/adpater"));
 const ble_interface_1 = __importDefault(require("../ble-interface"));
 const INTERFACE_NAME = 'ble';
 class BleAdapter extends adpater_1.default {
@@ -134,10 +110,10 @@ class BleAdapter extends adpater_1.default {
         this.dataMsgCount++;
         this.lastDataTS = Date.now();
         this.deviceData = Object.assign({}, deviceData);
-        if (!this.started || !this.canSendUpdate())
+        if (!this.started || !this.canEmitData())
             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 +208,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

@@ -4,9 +4,8 @@ import { EventLogger } from 'gd-eventlog';
 import BleAdapterFactory from './adapter-factory';
 import { BleInterfaceProps, BlePeripheral, BleDeviceSettings, BleProtocol, BleBinding, BleInterfaceState, BleScanProps, BleCharacteristic } from './types';
 import { BleComms } from './base/comms';
-import { IncyclistInterface } from '../types/interface';
+import { IncyclistInterface, IncyclistScanProps } from '../types';
 import BleAdapter from './base/adapter';
-import { IncyclistScanProps } from '../types/device';
 import BlePeripheralCache from './peripheral-cache';
 import EventEmitter from 'events';
 export interface ScanState {
@@ -40,7 +39,7 @@ export default class BleInterface extends EventEmitter implements IncyclistInter
     logger: EventLogger;
     props: BleInterfaceProps;
     binding: BleBinding;
-    connectedDevices: BleAdapter[];
+    connectedDevices: Array<BleAdapter>;
     sensorIsConnecting: boolean;
     emittingAdapters: {
         comms: BleComms;

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

@@ -1,22 +1,17 @@
-import CyclingMode from '../../modes/cycling-mode';
-import { IncyclistBikeData } from '../../modes/cycling-mode';
-import { BleControllableAdapter } from '../base/adapter';
-import { DeviceProperties } from '../../types/device';
+import BleAdapter from '../base/adapter';
 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 { DeviceProperties, IncyclistBikeData, IncyclistAdapterData, ControllerConfig, IAdapter } from '../../types';
+export default class PwrAdapter extends BleAdapter {
+    protected static controllers: ControllerConfig;
     distanceInternal: number;
     constructor(settings: BleDeviceSettings, props?: DeviceProperties);
-    isSame(device: IncyclistDevice): boolean;
+    isSame(device: IAdapter): boolean;
     getProfile(): string;
     getName(): string;
     getDisplayName(): string;
-    getDefaultCyclingMode(): CyclingMode;
-    getSupportedCyclingModes(): any[];
     mapData(deviceData: PowerData): IncyclistBikeData;
-    transformData(bikeData: IncyclistBikeData): DeviceData;
+    transformData(bikeData: IncyclistBikeData): IncyclistAdapterData;
     sendUpdate(request: any): Promise<void>;
     stop(): Promise<boolean>;
 }

package/lib/ble/cp/adapter.js

@@ -13,21 +13,20 @@ 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 capabilities_1 = require("../../types/capabilities");
-class PwrAdapter extends adapter_1.BleControllableAdapter {
+const adapter_1 = __importDefault(require("../base/adapter"));
+const types_1 = require("../../types");
+const power_meter_1 = __importDefault(require("../../modes/power-meter"));
+class PwrAdapter extends adapter_1.default {
     constructor(settings, props) {
         super(settings, props);
         this.distanceInternal = 0;
         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
+            types_1.IncyclistCapability.Power, types_1.IncyclistCapability.Cadence, types_1.IncyclistCapability.Speed
         ];
     }
     isSame(device) {
@@ -47,12 +46,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,
@@ -108,4 +101,8 @@ class PwrAdapter extends adapter_1.BleControllableAdapter {
         });
     }
 }
+PwrAdapter.controllers = {
+    modes: [power_meter_1.default],
+    default: power_meter_1.default
+};
 exports.default = PwrAdapter;

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

@@ -1,19 +1,19 @@
-import BleAdapter, { BleControllableAdapter } from '../base/adapter';
-import CyclingMode, { IncyclistBikeData } from '../../modes/cycling-mode';
+import BleAdapter from '../base/adapter';
+import ICyclingMode from '../../modes/types';
 import { PowerData } from '../cp';
-import { DeviceProperties } from '../../types/device';
-import { DeviceData } from '../../types/data';
+import { DeviceProperties, IncyclistAdapterData, IncyclistBikeData, ControllerConfig, IAdapter } from '../../types';
 import { BleDeviceSettings } from '../types';
-export default class BleEliteAdapter extends BleControllableAdapter {
+export default class BleEliteAdapter extends BleAdapter {
+    protected static controllers: ControllerConfig;
     distanceInternal: number;
     constructor(settings: BleDeviceSettings, props?: DeviceProperties);
-    isSame(device: BleAdapter): boolean;
+    isSame(device: IAdapter): boolean;
     getProfile(): string;
     getName(): string;
-    getDefaultCyclingMode(): CyclingMode;
+    getDefaultCyclingMode(): ICyclingMode;
     getSupportedCyclingModes(): any[];
     mapData(deviceData: PowerData): IncyclistBikeData;
-    transformData(bikeData: IncyclistBikeData): DeviceData;
+    transformData(bikeData: IncyclistBikeData): IncyclistAdapterData;
     start(props?: any): Promise<any>;
     sendUpdate(request: any): Promise<void>;
 }