incyclist-devices 2.1.0 → 2.1.2

package/lib/base/adpater.js

@@ -12,15 +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.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;
-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();
@@ -31,220 +24,205 @@ 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;
+        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 this.logger; }
-    isControllable() {
-        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; }
-    hasCapability(capability) {
-        return this.capabilities.find(c => c === capability) !== undefined;
-    }
-    addCapability(capability) {
-        if (!this.capabilities.includes(capability))
-            this.capabilities.push(capability);
-    }
-    update() { throw new Error("Method not implemented."); }
-    start(props) { throw new Error("Method not implemented."); }
-    stop() { throw new Error("Method not implemented."); }
-    pause() {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.paused = true;
-            return true;
-        });
-    }
-    resume() {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.paused = false;
-            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();
+            const logText = `~~~ ${this.getInterface()}: ${this.logger.getName()}`;
             console.log(logText, event);
         }
     }
-    getMaxUpdateFrequency() {
-        return this.updateFrequency;
-    }
-    setMaxUpdateFrequency(value) {
-        this.updateFrequency = value;
-    }
-    sendUpdate(request) { throw new Error("Method not implemented."); }
-    getID() { throw new Error('not implemented'); }
-    getDisplayName() {
-        return this.getName();
-    }
     getName() {
         return this.settings.name;
     }
+    getID() { throw new Error('not implemented'); }
     getUniqueName() {
         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();
     }
-    onData(callback) {
-        this.onDataFn = callback;
+    check() { throw new Error("Method not implemented."); }
+    start(props) { throw new Error("Method not implemented."); }
+    stop() { throw new Error("Method not implemented."); }
+    pause() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.paused = true;
+            return true;
+        });
     }
-    canSendUpdate() {
-        const updateFrequency = this.getMaxUpdateFrequency();
-        if (updateFrequency === -1 || updateFrequency === undefined)
+    resume() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.paused = false;
             return true;
-        return (!this.lastUpdate || (Date.now() - this.lastUpdate) > updateFrequency);
+        });
     }
-    emitData(data) {
-        if (!this.canSendUpdate())
-            return;
-        if (this.onDataFn)
-            this.onDataFn(data);
-        this.emit('data', this.getSettings(), data);
-        this.lastUpdate = Date.now();
+    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;
     }
-    isStopped() {
-        return this.stopped;
+    isControllable() {
+        if (!this.getControllerInfo())
+            return false;
+        return true;
     }
-    isStarted() {
-        return this.started;
+    getCapabilities() { return this.capabilities; }
+    hasCapability(capability) {
+        return this.capabilities.find(c => c === capability) !== undefined;
     }
-    isPaused() {
-        return this.paused;
+    addCapability(capability) {
+        if (!this.capabilities.includes(capability))
+            this.capabilities.push(capability);
     }
-    hasDataListeners() {
-        return this.onDataFn || this.listenerCount('data') > 0;
+    getMaxUpdateFrequency() {
+        return this.updateFrequency;
+    }
+    setMaxUpdateFrequency(value) {
+        this.updateFrequency = value;
     }
+    update() { throw new Error("Method not implemented."); }
     setCyclingMode(mode, settings, sendInitCommands) {
-        var _a;
-        if (this.isControllable())
-            (_a = this.bikeControl) === null || _a === void 0 ? void 0 : _a.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);
     }
     getSupportedCyclingModes() {
-        var _a;
         if (!this.isControllable())
             return [];
-        return (_a = this.bikeControl) === null || _a === void 0 ? void 0 : _a.getSupportedCyclingModes();
+        const config = this.getControllerInfo();
+        return config.modes;
     }
     getCyclingMode() {
         if (this.isControllable())
-            return this.bikeControl.getCyclingMode();
+            return this.cyclingMode;
     }
     getDefaultCyclingMode() {
-        if (this.isControllable())
-            return this.bikeControl.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) {
-        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();
+        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* () {
-            if (this.isControllable())
-                return yield this.bikeControl.sendInitCommands();
             return false;
         });
     }
-}
-exports.default = IncyclistDevice;
-class NonControllableDevice extends adapter_1.Controllable {
-    isControllable() {
-        return false;
-    }
-    setCyclingMode(mode, settings, sendInitCommands) {
-        throw new Error("Method not implemented.");
-    }
-    getSupportedCyclingModes() {
+    sendUpdate(request) {
+        if (!this.isControllable())
+            return;
         throw new Error("Method not implemented.");
     }
-    getCyclingMode() {
-        throw new Error("Method not implemented.");
+    setUser(user) {
+        this.user = user;
+        if (!user.weight)
+            this.user.weight = consts_1.DEFAULT_USER_WEIGHT;
     }
-    getDefaultCyclingMode() {
-        throw new Error("Method not implemented.");
+    getUser() {
+        return this.user;
     }
-    setBikeProps(props) {
-        throw new Error("Method not implemented.");
+    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;
     }
-    setUser(user) {
-        throw new Error("Method not implemented.");
+    isUpdateWithinFrequency() {
+        const updateFrequency = this.getMaxUpdateFrequency();
+        if (updateFrequency === -1 || updateFrequency === undefined)
+            return true;
+        return (!this.lastUpdate || (Date.now() - this.lastUpdate) > updateFrequency);
     }
-    sendInitCommands() {
-        return __awaiter(this, void 0, void 0, function* () {
+    canEmitData() {
+        if (this.paused || this.stopped)
             return false;
-        });
+        return this.isUpdateWithinFrequency();
     }
-}
-exports.NonControllableDevice = NonControllableDevice;
-class ControllableDevice extends adapter_1.Controllable {
-    constructor(adapter, props) {
-        super(adapter, props);
-        this.cyclingMode = this.getDefaultCyclingMode();
+    emitData(data) {
+        if (!this.canEmitData())
+            return;
+        if (this.onDataFn)
+            this.onDataFn(data);
+        this.emit('data', this.getSettings(), data);
+        this.lastUpdate = Date.now();
     }
-    isControllable() {
-        return true;
+    isStopped() {
+        return this.stopped;
     }
-    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.adapter); return m.getName() === mode; });
-            if (CyclingModeClass) {
-                this.cyclingMode = new CyclingModeClass(this.adapter, settings);
-                return;
-            }
-            selectedMode = this.getDefaultCyclingMode();
-        }
-        else {
-            selectedMode = mode;
-        }
-        this.cyclingMode = selectedMode;
-        this.cyclingMode.setSettings(settings);
+    isStarted() {
+        return this.started;
     }
-    sendInitCommands() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return true;
-        });
+    isPaused() {
+        return this.paused;
     }
-    getCyclingMode() {
-        if (!this.cyclingMode)
-            this.setCyclingMode(this.getDefaultCyclingMode());
-        return this.cyclingMode;
+    getData() {
+        return this.data;
     }
-    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;
+    hasDataListeners() {
+        return this.onDataFn || this.listenerCount('data') > 0;
+    }
+    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,31 +1,30 @@
-import { DeviceProperties } from "../types/device";
 import BleAdapter from "./base/adapter";
-import { BleDeviceProperties, BleDeviceSettings, BleProtocol } from "./types";
+import { BleDeviceSettings, BleProtocol } from "./types";
+import { DeviceProperties } from "../types";
 import { BleComms } from "./base/comms";
-import { Controllable } from "../types/adapter";
 export interface BleAdapterInfo {
     protocol: BleProtocol;
-    Adapter: typeof BleAdapter<Controllable<BleDeviceProperties>>;
+    Adapter: typeof BleAdapter;
     Comm: typeof BleComms;
 }
 export default class BleAdapterFactory {
     static _instance: BleAdapterFactory;
     implementations: BleAdapterInfo[];
-    instances: Array<BleAdapter<Controllable<BleDeviceProperties>>>;
+    instances: Array<BleAdapter>;
     static getInstance(): BleAdapterFactory;
     constructor();
     getAdapterInfo(protocol: BleProtocol): BleAdapterInfo;
     getAll(): BleAdapterInfo[];
-    createInstance(settings: BleDeviceSettings, props?: DeviceProperties): BleAdapter<Controllable<BleDeviceProperties>>;
+    createInstance(settings: BleDeviceSettings, props?: DeviceProperties): BleAdapter;
     removeInstance(query: {
         settings?: BleDeviceSettings;
-        adapter?: BleAdapter<Controllable<DeviceProperties>>;
+        adapter?: BleAdapter;
     }): void;
-    find(settings?: BleDeviceSettings): BleAdapter<Controllable<BleDeviceProperties>>;
-    register(protocol: BleProtocol, Adapter: typeof BleAdapter<Controllable<BleDeviceProperties>>, Comm: typeof BleComms): void;
-    getAllInstances(): Array<BleAdapter<Controllable<DeviceProperties>>>;
+    find(settings?: BleDeviceSettings): BleAdapter;
+    register(protocol: BleProtocol, Adapter: typeof BleAdapter, Comm: typeof BleComms): void;
+    getAllInstances(): Array<BleAdapter>;
     getAllSupportedComms(): (typeof BleComms)[];
-    getAllSupportedAdapters(): Array<(typeof BleAdapter<Controllable<BleDeviceProperties>>)>;
+    getAllSupportedAdapters(): Array<(typeof BleAdapter)>;
     getAllSupportedServices(): string[];
     getDeviceClasses(peripheral: any, props?: {
         protocol?: BleProtocol;

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

@@ -1,19 +1,12 @@
-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 IncyclistDevice from "../../base/adpater";
 import { BleComms } from "./comms";
 import BleInterface from "../ble-interface";
 import { BleDeviceProperties, BleDeviceSettings, BleStartProperties } from "../types";
-export declare class BlePowerControl extends ControllableDevice<BleDeviceProperties> {
-    getDefaultCyclingMode(): ICyclingMode;
-    getSupportedCyclingModes(): any[];
-}
-export default class BleAdapter<DC extends Controllable<BleDeviceProperties>> extends IncyclistDevice<DC, BleDeviceProperties> {
+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;
@@ -23,7 +16,7 @@ export default class BleAdapter<DC extends Controllable<BleDeviceProperties>> ex
     close(): Promise<boolean>;
     getComms(): BleComms;
     isEqual(settings: BleDeviceSettings): boolean;
-    isSame(adapter: IncyclistDeviceAdapter): boolean;
+    isSame(adapter: IAdapter): boolean;
     isConnected(): boolean;
     resetData(): void;
     getInterface(): string;
@@ -31,8 +24,8 @@ export default class BleAdapter<DC extends Controllable<BleDeviceProperties>> ex
     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>;

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,20 +12,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BlePowerControl = 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 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);
@@ -144,7 +110,7 @@ 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.isControllable() });
         if (this.isControllable()) {

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

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

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

@@ -1,19 +1,17 @@
-import { IncyclistBikeData } from '../../modes/types';
-import BleAdapter, { BlePowerControl } 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 { IncyclistDeviceAdapter } from '../../types/adapter';
-export default class PwrAdapter extends BleAdapter<BlePowerControl> {
+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: IncyclistDeviceAdapter): boolean;
+    isSame(device: IAdapter): boolean;
     getProfile(): string;
     getName(): string;
     getDisplayName(): string;
     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

@@ -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) {
@@ -37,19 +14,19 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const gd_eventlog_1 = require("gd-eventlog");
 const comm_1 = __importDefault(require("./comm"));
-const adapter_1 = __importStar(require("../base/adapter"));
-const capabilities_1 = require("../../types/capabilities");
+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.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;
         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) {
@@ -124,4 +101,8 @@ class PwrAdapter extends adapter_1.default {
         });
     }
 }
+PwrAdapter.controllers = {
+    modes: [power_meter_1.default],
+    default: power_meter_1.default
+};
 exports.default = PwrAdapter;