incyclist-devices 2.3.28 → 2.3.29

package/lib/ble/zwift/click/sensor.js

@@ -0,0 +1,221 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BleZwiftClickSensor = void 0;
+const sensor_1 = require("../../base/sensor");
+const utils_1 = require("../../utils");
+const crypto_1 = require("crypto");
+const stream_1 = require("stream");
+class BleZwiftClickSensor extends sensor_1.TBleSensor {
+    constructor(peripheral, props) {
+        super(peripheral, props);
+        this.emitter = new stream_1.EventEmitter();
+        this.setInitialState();
+    }
+    reconnectSensor() {
+        const _super = Object.create(null, {
+            reconnectSensor: { get: () => super.reconnectSensor }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            this.setInitialState();
+            let reconnected = yield _super.reconnectSensor.call(this);
+            this.pair();
+            return reconnected;
+        });
+    }
+    stopSensor() {
+        this.emitter.removeAllListeners();
+        this.setInitialState();
+        this.removeAllListeners('up');
+        this.removeAllListeners('down');
+        return super.stopSensor();
+    }
+    getRequiredCharacteristics() {
+        return ['00000002-19ca-4651-86e5-fa29dcdd09d1', '00000004-19ca-4651-86e5-fa29dcdd09d1'];
+    }
+    onData(characteristic, data, isNotify) {
+        const uuid = (0, utils_1.beautifyUUID)(characteristic).toLowerCase();
+        if (uuid === '00000002-19ca-4651-86e5-fa29dcdd09d1') {
+            this.onPlayMeasurement(data);
+        }
+        else if (uuid === '00000004-19ca-4651-86e5-fa29dcdd09d1') {
+            this.onPairResponse(data);
+        }
+        else {
+            console.log('data received ', isNotify ? 'N' : 'I', uuid, data.toString('hex'));
+        }
+        return true;
+    }
+    onPlayMeasurement(data) {
+        if ((data === null || data === void 0 ? void 0 : data.length) < 1) {
+            console.log('Invalid click measurement data', data.toString('hex'));
+            return false;
+        }
+        const type = data.readUInt8(0);
+        const message = data.subarray(1);
+        if (type === 0x37) {
+            this.onButtonMessage(message);
+        }
+        else if (type === 0x19) {
+            this.onPingMessage(message);
+        }
+        else {
+            console.log('Unknown click measurement type', type, message.toString('hex'));
+            this.emit('data', { raw: data.toString('hex') });
+        }
+        return true;
+    }
+    onButtonMessage(message) {
+        var _a, _b;
+        if (message.readUInt8(0) === 0x8 && message.length === 4) {
+            const value = message.subarray(1);
+            const messageStr = value.toString('hex');
+            if (messageStr === this.prevClickMessage) {
+                return;
+            }
+            switch (messageStr) {
+                case '001001':
+                    this.upState = { pressed: true, timestamp: Date.now() };
+                    break;
+                case '011001':
+                    if ((_a = this.upState) === null || _a === void 0 ? void 0 : _a.pressed) {
+                        const prev = Object.assign({}, this.upState);
+                        this.upState = { pressed: false, timestamp: Date.now() };
+                        this.emit('up', this.upState.timestamp - prev.timestamp);
+                    }
+                    else if ((_b = this.downState) === null || _b === void 0 ? void 0 : _b.pressed) {
+                        const prev = Object.assign({}, this.downState);
+                        this.downState = { pressed: false, timestamp: Date.now() };
+                        this.emit('down', this.downState.timestamp - prev.timestamp);
+                    }
+                    else {
+                        this.upState = { pressed: false, timestamp: Date.now() };
+                        this.downState = { pressed: false, timestamp: Date.now() };
+                    }
+                    break;
+                case '011000':
+                    this.downState = { pressed: true, timestamp: Date.now() };
+                    break;
+            }
+            this.prevClickMessage = messageStr;
+        }
+        else {
+            console.log('Click measurement received', message.toString('hex'), message.readUInt8(0), message.length);
+        }
+    }
+    onPingMessage(message) {
+        this.emit('data', { deviceType: this.deviceType, paired: this.paired, alive: true, ts: Date.now() });
+    }
+    onPairResponse(data) {
+        const len = data.length;
+        if (len === 6 && data.toString() === 'RideOn') {
+            this.encrypted = false;
+            this.paired = true;
+            this.emitter.emit('paired');
+            try {
+                this.emit('data', { deviceType: this.deviceType, paired: true, ts: Date.now() });
+            }
+            catch (e) {
+                console.error('Error emitting data:', e);
+            }
+        }
+        else if (len > 8 && data.subarray(0, 6).toString() === 'RideOn') {
+            const message = data.subarray(6, 2).toString('hex');
+            if (message === '0900') {
+                this.encrypted = true;
+                this.paired = true;
+                this.deviceKey = data.subarray(8);
+                this.emitter.emit('paired');
+                try {
+                    this.emit('data', { deviceType: this.deviceType, paired: true, ts: Date.now() });
+                }
+                catch (e) {
+                    console.error('Error emitting data:', e);
+                }
+            }
+            else {
+                console.log('Pairing failed! ', { reason: 'unknown message', message });
+            }
+        }
+        return true;
+    }
+    read(characteristic_1) {
+        const _super = Object.create(null, {
+            read: { get: () => super.read }
+        });
+        return __awaiter(this, arguments, void 0, function* (characteristic, ignoreErrors = false) {
+            try {
+                return yield _super.read.call(this, characteristic);
+            }
+            catch (error) {
+                if (!ignoreErrors)
+                    throw error;
+                return null;
+            }
+        });
+    }
+    pair() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            try {
+                if (this.peripheral.getManufacturerData) {
+                    const manufacturerData = this.peripheral.getManufacturerData();
+                    if (manufacturerData === null || manufacturerData === void 0 ? void 0 : manufacturerData.startsWith('4a09')) {
+                        const typeVal = Number('0x' + manufacturerData.substring(2, 4));
+                        if (typeVal === 9) {
+                            this.deviceType = 'click';
+                        }
+                        else if (typeVal === 2) {
+                            this.deviceType = 'right';
+                        }
+                        else if (typeVal === 3) {
+                            this.deviceType = 'left';
+                        }
+                    }
+                }
+                let message;
+                if (this.deviceType === 'click') {
+                    message = Buffer.from('RideOn');
+                    this.encrypted = false;
+                }
+                else {
+                    const { publicKey, privateKey } = (0, crypto_1.generateKeyPairSync)('ec', {
+                        namedCurve: 'prime256v1',
+                        publicKeyEncoding: { type: 'spki', format: 'der' },
+                        privateKeyEncoding: { type: 'pkcs8', format: 'der' }
+                    });
+                    this.privateKey = (_a = this.privateKey) !== null && _a !== void 0 ? _a : Buffer.from(privateKey);
+                    this.publicKey = (_b = this.publicKey) !== null && _b !== void 0 ? _b : Buffer.from(publicKey);
+                    message = Buffer.concat([Buffer.from('RideOn'), Buffer.from([0x01, 0x02]), this.publicKey]);
+                }
+                yield this.write((0, utils_1.fullUUID)('00000003-19ca-4651-86e5-fa29dcdd09d1'), message, { withoutResponse: true });
+                return true;
+            }
+            catch (error) {
+                console.error('Error pairing:', error);
+                return false;
+            }
+        });
+    }
+    reset() {
+    }
+    setInitialState() {
+        this.paired = false;
+        this.encrypted = false;
+        this.deviceKey = null;
+    }
+}
+exports.BleZwiftClickSensor = BleZwiftClickSensor;
+BleZwiftClickSensor.profile = 'Controller';
+BleZwiftClickSensor.protocol = 'zwift-click';
+BleZwiftClickSensor.services = ['0000000119ca465186e5fa29dcdd09d1'];
+BleZwiftClickSensor.characteristics = [];
+BleZwiftClickSensor.detectionPriority = 1;

package/lib/ble/zwift/play/adapter.d.ts

@@ -0,0 +1,19 @@
+import { BleDeviceData } from '../../base/types';
+import { LegacyProfile } from '../../../antv2/types';
+import BleAdapter from '../../base/adapter';
+import { BleZwiftPlaySensor } from './sensor';
+import { DeviceProperties, IAdapter, IncyclistAdapterData, IncyclistCapability } from '../../../types';
+import { BleDeviceSettings, BleStartProperties, IBlePeripheral } from '../../types';
+export declare class ZwiftPlayAdapter extends BleAdapter<BleDeviceData, BleZwiftPlaySensor> {
+    protected static INCYCLIST_PROFILE_NAME: LegacyProfile;
+    protected static CAPABILITIES: IncyclistCapability[];
+    constructor(settings: BleDeviceSettings, props?: DeviceProperties);
+    protected checkCapabilities(): Promise<void>;
+    start(startProps?: BleStartProperties): Promise<boolean>;
+    startSensor(): Promise<boolean>;
+    isSame(adapter: IAdapter): boolean;
+    updateSensor(peripheral: IBlePeripheral): void;
+    getProfile(): LegacyProfile;
+    getDisplayName(): string;
+    mapData(deviceData: BleDeviceData): IncyclistAdapterData;
+}

package/lib/ble/zwift/play/adapter.js

@@ -0,0 +1,76 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZwiftPlayAdapter = void 0;
+const gd_eventlog_1 = require("gd-eventlog");
+const adapter_1 = __importDefault(require("../../base/adapter"));
+const sensor_1 = require("./sensor");
+const types_1 = require("../../../types");
+class ZwiftPlayAdapter extends adapter_1.default {
+    constructor(settings, props) {
+        super(settings, props);
+        this.logger = new gd_eventlog_1.EventLogger('ZwiftPlay');
+        this.device = new sensor_1.BleZwiftPlaySensor(this.getPeripheral(), { logger: this.logger });
+        this.capabilities = ZwiftPlayAdapter.CAPABILITIES;
+    }
+    checkCapabilities() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return;
+        });
+    }
+    start(startProps) {
+        return super.start(startProps);
+    }
+    startSensor() {
+        const _super = Object.create(null, {
+            startSensor: { get: () => super.startSensor }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                let connected = yield _super.startSensor.call(this);
+                if (connected) {
+                    const sensor = this.getSensor();
+                    sensor.on('key-pressed', (event) => {
+                        this.emit('key-pressed', this.getSettings(), event);
+                    });
+                }
+                return connected;
+            }
+            catch (err) {
+                this.logEvent({ message: 'error', fn: 'startSensor', error: err.message, stack: err.stack });
+                return false;
+            }
+        });
+    }
+    isSame(adapter) {
+        if (!(adapter instanceof ZwiftPlayAdapter))
+            return false;
+        return this.isEqual(adapter.settings);
+    }
+    updateSensor(peripheral) {
+        this.device = new sensor_1.BleZwiftPlaySensor(peripheral, { logger: this.logger });
+    }
+    getProfile() {
+        return ZwiftPlayAdapter.INCYCLIST_PROFILE_NAME;
+    }
+    getDisplayName() {
+        return this.getName();
+    }
+    mapData(deviceData) {
+        return {};
+    }
+}
+exports.ZwiftPlayAdapter = ZwiftPlayAdapter;
+ZwiftPlayAdapter.INCYCLIST_PROFILE_NAME = 'Controller';
+ZwiftPlayAdapter.CAPABILITIES = [types_1.IncyclistCapability.AppControl];

package/lib/ble/zwift/play/index.d.ts

@@ -0,0 +1,2 @@
+export * from './sensor';
+export * from './adapter';

package/lib/ble/zwift/play/index.js

@@ -0,0 +1,18 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./sensor"), exports);
+__exportStar(require("./adapter"), exports);

package/lib/ble/zwift/play/sensor.d.ts

@@ -0,0 +1,43 @@
+import { LegacyProfile } from "incyclist-devices/lib/antv2/types";
+import { TBleSensor } from "../../base/sensor";
+import { BleProtocol } from "../../types";
+import { EventEmitter } from "events";
+type ButtonState = {
+    pressed: boolean;
+    timestamp: number;
+};
+type DeviceType = 'left' | 'right' | 'click';
+export declare class BleZwiftPlaySensor extends TBleSensor {
+    static readonly profile: LegacyProfile;
+    static readonly protocol: BleProtocol;
+    static readonly services: string[];
+    static readonly characteristics: any[];
+    static readonly detectionPriority = 1;
+    protected emitter: EventEmitter;
+    protected paired: boolean;
+    protected encrypted: boolean;
+    protected deviceKey: Buffer;
+    protected prevClickMessage: string;
+    protected upState: ButtonState;
+    protected downState: ButtonState;
+    protected deviceType: DeviceType;
+    protected publicKey: Buffer;
+    protected privateKey: Buffer;
+    constructor(peripheral: any, props?: any);
+    reconnectSensor(): Promise<void>;
+    stopSensor(): Promise<boolean>;
+    protected getRequiredCharacteristics(): Array<string>;
+    onData(characteristic: string, data: Buffer, isNotify?: boolean): boolean;
+    onPlayMeasurement(d: Buffer): boolean;
+    onButtonMessage(d: Buffer): void;
+    onPingMessage(d: Buffer): void;
+    onPairResponse(d: Buffer): boolean;
+    read(characteristic: string, ignoreErrors?: boolean): Promise<Buffer | null>;
+    pair(): Promise<boolean>;
+    reset(): void;
+    protected encrpytedSupported(): boolean;
+    protected createKeyPair(): import("crypto").KeyPairSyncResult<Buffer<ArrayBufferLike>, Buffer<ArrayBufferLike>>;
+    protected setInitialState(): void;
+    protected getManufacturerData(): string;
+}
+export {};

package/lib/ble/zwift/play/sensor.js

@@ -0,0 +1,246 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BleZwiftPlaySensor = void 0;
+const sensor_1 = require("../../base/sensor");
+const utils_1 = require("../../utils");
+const crypto_1 = require("crypto");
+const events_1 = require("events");
+class BleZwiftPlaySensor extends sensor_1.TBleSensor {
+    constructor(peripheral, props) {
+        super(peripheral, props);
+        this.emitter = new events_1.EventEmitter();
+        this.setInitialState();
+    }
+    reconnectSensor() {
+        const _super = Object.create(null, {
+            reconnectSensor: { get: () => super.reconnectSensor }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            this.setInitialState();
+            let reconnected = yield _super.reconnectSensor.call(this);
+            this.pair();
+            return reconnected;
+        });
+    }
+    stopSensor() {
+        this.emitter.removeAllListeners();
+        this.setInitialState();
+        this.removeAllListeners('key-pressed');
+        return super.stopSensor();
+    }
+    getRequiredCharacteristics() {
+        return ['00000002-19ca-4651-86e5-fa29dcdd09d1', '00000004-19ca-4651-86e5-fa29dcdd09d1'];
+    }
+    onData(characteristic, data, isNotify) {
+        const uuid = (0, utils_1.beautifyUUID)(characteristic).toLowerCase();
+        if (uuid === '00000002-19ca-4651-86e5-fa29dcdd09d1') {
+            this.onPlayMeasurement(data);
+        }
+        else if (uuid === '00000004-19ca-4651-86e5-fa29dcdd09d1') {
+            this.onPairResponse(data);
+        }
+        else {
+            console.log('data received ', isNotify ? 'N' : 'I', uuid, data.toString('hex'));
+        }
+        return true;
+    }
+    onPlayMeasurement(d) {
+        const data = Buffer.from(d);
+        if ((data === null || data === void 0 ? void 0 : data.length) < 1) {
+            console.log('Invalid click measurement data', data.toString('hex'));
+            return false;
+        }
+        const type = data.readUInt8(0);
+        const message = data.subarray(1);
+        if (type === 0x37) {
+            this.onButtonMessage(message);
+        }
+        else if (type === 0x19) {
+            this.onPingMessage(message);
+        }
+        else {
+            console.log('Unknown click measurement type', type, message.toString('hex'));
+            this.emit('data', { raw: data.toString('hex') });
+        }
+        return true;
+    }
+    onButtonMessage(d) {
+        var _a, _b;
+        const message = Buffer.from(d);
+        try {
+            if (message.readUInt8(0) === 0x8 && message.length === 4) {
+                const value = Buffer.from(message.subarray(1));
+                const messageStr = value.toString('hex');
+                if (messageStr === this.prevClickMessage) {
+                    return;
+                }
+                switch (messageStr) {
+                    case '001001':
+                        this.upState = { pressed: true, timestamp: Date.now() };
+                        break;
+                    case '011001':
+                        if ((_a = this.upState) === null || _a === void 0 ? void 0 : _a.pressed) {
+                            const prev = Object.assign({}, this.upState);
+                            this.upState = { pressed: false, timestamp: Date.now() };
+                            this.emit('key-pressed', { key: 'up', duration: this.upState.timestamp - prev.timestamp, deviceType: this.deviceType });
+                        }
+                        else if ((_b = this.downState) === null || _b === void 0 ? void 0 : _b.pressed) {
+                            const prev = Object.assign({}, this.downState);
+                            this.downState = { pressed: false, timestamp: Date.now() };
+                            this.emit('key-pressed', { key: 'down', duration: this.downState.timestamp - prev.timestamp, deviceType: this.deviceType });
+                        }
+                        else {
+                            this.upState = { pressed: false, timestamp: Date.now() };
+                            this.downState = { pressed: false, timestamp: Date.now() };
+                        }
+                        break;
+                    case '011000':
+                        this.downState = { pressed: true, timestamp: Date.now() };
+                        break;
+                }
+                this.prevClickMessage = messageStr;
+            }
+            else {
+                this.logEvent({ message: 'Click measurement received', raw: message.toString('hex') });
+            }
+        }
+        catch (err) {
+            this.logEvent({ message: 'error', fn: 'onButtonMessage', error: err.message, stack: err.stack });
+        }
+    }
+    onPingMessage(d) {
+        this.emit('data', { deviceType: this.deviceType, paired: this.paired, alive: true, ts: Date.now() });
+    }
+    onPairResponse(d) {
+        const data = Buffer.from(d);
+        const len = data.length;
+        if (len === 6 && data.toString() === 'RideOn') {
+            this.encrypted = false;
+            this.paired = true;
+            this.emitter.emit('paired');
+            try {
+                this.emit('data', { deviceType: this.deviceType, paired: true, ts: Date.now() });
+            }
+            catch (err) {
+                this.logEvent({ message: 'error', fn: 'onPairResponse', error: err.message, stack: err.stack });
+            }
+        }
+        else if (len > 8 && Buffer.from(data.subarray(0, 6)).toString() === 'RideOn') {
+            const message = Buffer.from(data.subarray(6, 2)).toString('hex');
+            if (message === '0900') {
+                this.encrypted = true;
+                this.paired = true;
+                this.deviceKey = data.subarray(8);
+                this.emitter.emit('paired');
+                try {
+                    this.emit('data', { deviceType: this.deviceType, paired: true, ts: Date.now() });
+                }
+                catch (err) {
+                    this.logEvent({ message: 'error', fn: 'onPairResponse', error: err.message, stack: err.stack });
+                }
+            }
+            else {
+                this.logEvent({ message: 'Pairing failed! ', reason: 'unknown message', raw: message });
+            }
+        }
+        return true;
+    }
+    read(characteristic_1) {
+        const _super = Object.create(null, {
+            read: { get: () => super.read }
+        });
+        return __awaiter(this, arguments, void 0, function* (characteristic, ignoreErrors = false) {
+            try {
+                return yield _super.read.call(this, characteristic);
+            }
+            catch (error) {
+                if (!ignoreErrors)
+                    throw error;
+                return null;
+            }
+        });
+    }
+    pair() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            try {
+                if (this.peripheral.getManufacturerData) {
+                    const manufacturerData = this.getManufacturerData();
+                    if (manufacturerData === null || manufacturerData === void 0 ? void 0 : manufacturerData.startsWith('4a09')) {
+                        const typeVal = Number('0x' + manufacturerData.substring(2, 4));
+                        if (typeVal === 9) {
+                            this.deviceType = 'click';
+                        }
+                        else if (typeVal === 2) {
+                            this.deviceType = 'right';
+                        }
+                        else if (typeVal === 3) {
+                            this.deviceType = 'left';
+                        }
+                    }
+                }
+                else if (!this.encrpytedSupported()) {
+                    this.deviceType = 'click';
+                }
+                let message;
+                if (this.deviceType === 'click') {
+                    message = Buffer.from('RideOn');
+                    this.encrypted = false;
+                }
+                else {
+                    const { publicKey, privateKey } = this.createKeyPair();
+                    this.privateKey = (_a = this.privateKey) !== null && _a !== void 0 ? _a : Buffer.from(privateKey);
+                    this.publicKey = (_b = this.publicKey) !== null && _b !== void 0 ? _b : Buffer.from(publicKey);
+                    message = Buffer.concat([Buffer.from('RideOn'), Buffer.from([0x01, 0x02]), this.publicKey]);
+                }
+                yield this.write((0, utils_1.fullUUID)('00000003-19ca-4651-86e5-fa29dcdd09d1'), message, { withoutResponse: true });
+                return true;
+            }
+            catch (err) {
+                this.logEvent({ message: 'error', fn: 'pair', error: err.message, stack: err.stack });
+                return false;
+            }
+        });
+    }
+    reset() {
+    }
+    encrpytedSupported() {
+        return crypto_1.generateKeyPairSync !== undefined && typeof (crypto_1.generateKeyPairSync) === 'function';
+    }
+    createKeyPair() {
+        return (0, crypto_1.generateKeyPairSync)('ec', {
+            namedCurve: 'prime256v1',
+            publicKeyEncoding: { type: 'spki', format: 'der' },
+            privateKeyEncoding: { type: 'pkcs8', format: 'der' }
+        });
+    }
+    setInitialState() {
+        this.paired = false;
+        this.encrypted = false;
+        this.deviceKey = null;
+    }
+    getManufacturerData() {
+        const data = this.peripheral.getManufacturerData();
+        if (typeof data === 'string')
+            return data;
+        if (Buffer.isBuffer(data)) {
+            return data.toString('hex');
+        }
+        return undefined;
+    }
+}
+exports.BleZwiftPlaySensor = BleZwiftPlaySensor;
+BleZwiftPlaySensor.profile = 'Controller';
+BleZwiftPlaySensor.protocol = 'zwift-play';
+BleZwiftPlaySensor.services = ['0000000119ca465186e5fa29dcdd09d1'];
+BleZwiftPlaySensor.characteristics = [];
+BleZwiftPlaySensor.detectionPriority = 1;

package/lib/modes/power-base.js

@@ -54,10 +54,12 @@ class PowerBasedCyclingModeBase extends base_1.CyclingModeBase {
         }
     }
     checkRefresh(request, newRequest) {
+        var _a;
         if (request.refresh && request.targetPower === undefined) {
             delete request.refresh;
-            if (this.prevRequest)
-                newRequest.targetPower = this.prevRequest.targetPower;
+            if (this.prevRequest) {
+                newRequest.targetPower = (_a = this.prevRequest.targetPower) !== null && _a !== void 0 ? _a : this.data.power;
+            }
         }
     }
     checkTargetPowerSet(request, newRequest) {
@@ -73,9 +75,19 @@ class PowerBasedCyclingModeBase extends base_1.CyclingModeBase {
         }
     }
     checkSlope(request) {
+        var _a;
         if (request.slope !== undefined) {
             this.data.slope = request.slope;
             delete request.slope;
+            if (request.targetPower === undefined && request.minPower === undefined && request.maxPower === undefined) {
+                if (this.prevRequest) {
+                    this.prevRequest.targetPower = (_a = this.prevRequest.targetPower) !== null && _a !== void 0 ? _a : (this.data.power || undefined);
+                }
+                else {
+                    this.prevRequest = { targetPower: this.data.power || undefined };
+                }
+                request.refresh = this.prevRequest.targetPower !== undefined;
+            }
         }
     }
     checkEmptyRequest(newRequest) {
@@ -213,8 +225,10 @@ class PowerBasedCyclingModeBase extends base_1.CyclingModeBase {
         const request = Object.assign({}, incoming);
         try {
             const req = this.checkForResetOrEmpty(request);
-            if (req)
+            if (req) {
+                delete req.refresh;
                 return req;
+            }
             this.checkSlope(request);
             this.checkForTempPowerAdjustments(request);
             this.checkTargetPowerSet(request, newRequest);