incyclist-devices 2.0.37 → 2.1.0

package/lib/modes/power-base.d.ts

@@ -1,20 +1,45 @@
-import { IncyclistBikeData, Settings, CyclingModeBase } from './cycling-mode';
+import { CyclingModeConfig, IncyclistBikeData, Settings, UpdateRequest } from './types';
 import { EventLogger } from 'gd-eventlog';
-import { ControllableDeviceAdapter } from '..';
+import { IncyclistDeviceAdapter } from '..';
+import { CyclingModeBase } from './base';
 export default class PowerBasedCyclingModeBase extends CyclingModeBase {
     data: IncyclistBikeData;
     prevUpdateTS: number;
     logger: EventLogger;
-    constructor(adapter: ControllableDeviceAdapter, props?: Settings);
+    prevRequest: UpdateRequest | undefined;
+    protected static config: CyclingModeConfig;
+    constructor(adapter: IncyclistDeviceAdapter, props?: Settings);
+    getData(): IncyclistBikeData;
+    getSlope(): number;
     initLogger(defaultLogName: any): void;
     getWeight(): number;
     getTimeSinceLastUpdate(): number;
+    checkForResetOrEmpty(request: UpdateRequest): UpdateRequest | undefined;
+    protected checkForTempPowerAdjustments(request: UpdateRequest): void;
+    protected checkRefresh(request: UpdateRequest, newRequest: UpdateRequest): void;
+    protected checkTargetPowerSet(request: UpdateRequest, newRequest: UpdateRequest): void;
+    protected checkSlope(request: UpdateRequest): void;
+    protected checkEmptyRequest(newRequest: UpdateRequest): void;
+    protected checkMinPower(request: UpdateRequest, newRequest: UpdateRequest): void;
+    protected checkMaxPower(request: UpdateRequest, newRequest: UpdateRequest): void;
     calculateSpeedAndDistance(power: number, slope: number, m: number, t: number, props?: {}): {
         speed: number;
         distance: number;
     };
+    protected updateSpeedAndDistance(power: number, slope: any, bikeType: any, data: IncyclistBikeData, prevData: any): number;
+    protected getCalcBasics(bikeData: IncyclistBikeData): {
+        data: IncyclistBikeData;
+        prevData: any;
+        prevRequest: UpdateRequest;
+        bikeType: any;
+        slope: any;
+    };
+    copyBikeData(data: IncyclistBikeData, bikeData: IncyclistBikeData): IncyclistBikeData;
     calculatePowerAndDistance(speed: number, slope: number, m: number, t: number, props?: {}): {
         power: number;
         distance: number;
     };
+    getBikeInitRequest(): UpdateRequest;
+    sendBikeUpdate(incoming: UpdateRequest): UpdateRequest;
+    updateData(bikeData: IncyclistBikeData, log?: boolean): IncyclistBikeData;
 }

package/lib/modes/power-base.js

@@ -3,16 +3,24 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const cycling_mode_1 = require("./cycling-mode");
 const adpater_1 = require("../base/adpater");
 const calculations_1 = __importDefault(require("../utils/calculations"));
 const gd_eventlog_1 = require("gd-eventlog");
-class PowerBasedCyclingModeBase extends cycling_mode_1.CyclingModeBase {
+const base_1 = require("./base");
+const MIN_SPEED = 10;
+class PowerBasedCyclingModeBase extends base_1.CyclingModeBase {
     constructor(adapter, props) {
         super(adapter, props);
         this.prevUpdateTS = 0;
         this.data = { speed: 0, power: 0, distanceInternal: 0, pedalRpm: 0, isPedalling: false, heartrate: 0 };
     }
+    getData() {
+        return this.data;
+    }
+    getSlope() {
+        const { slope } = this.data;
+        return slope || 0;
+    }
     initLogger(defaultLogName) {
         const a = this.adapter;
         this.logger = a.getLogger();
@@ -28,11 +36,86 @@ class PowerBasedCyclingModeBase extends cycling_mode_1.CyclingModeBase {
     getTimeSinceLastUpdate() {
         const ts = Date.now();
         const duration = this.prevUpdateTS === 0 ? 0 : ((ts - this.prevUpdateTS) / 1000);
-        this.prevUpdateTS = ts;
         return duration;
     }
+    checkForResetOrEmpty(request) {
+        if (!request || request.reset) {
+            this.prevRequest = {};
+            return { reset: true };
+        }
+        if (Object.keys(request).length === 0 && this.prevRequest) {
+            return { targetPower: this.prevRequest.targetPower, refresh: true };
+        }
+    }
+    checkForTempPowerAdjustments(request) {
+        if (request.targetPowerDelta && this.prevRequest && this.prevRequest.targetPower) {
+            request.targetPower = this.prevRequest.targetPower + request.targetPowerDelta;
+            if (request.targetPower < 10)
+                request.targetPower = this.prevRequest.targetPower;
+            delete request.targetPowerDelta;
+        }
+    }
+    checkRefresh(request, newRequest) {
+        if (request.refresh && request.targetPower === undefined) {
+            delete request.refresh;
+            if (this.prevRequest)
+                newRequest.targetPower = this.prevRequest.targetPower;
+        }
+    }
+    checkTargetPowerSet(request, newRequest) {
+        let target = undefined;
+        if (request.targetPower !== undefined)
+            target = request.targetPower;
+        if (request.targetPower === undefined && request.maxPower !== undefined && request.minPower !== undefined && request.maxPower === request.minPower) {
+            target = request.minPower;
+        }
+        if (target !== undefined) {
+            delete request.refresh;
+            newRequest.targetPower = Number(target);
+        }
+    }
+    checkSlope(request) {
+        if (request.slope !== undefined) {
+            this.data.slope = request.slope;
+            delete request.slope;
+        }
+    }
+    checkEmptyRequest(newRequest) {
+        if (Object.keys(newRequest).length === 0) {
+            if (this.prevRequest) {
+                newRequest.targetPower = this.prevRequest.targetPower;
+                newRequest.refresh = true;
+            }
+        }
+    }
+    checkMinPower(request, newRequest) {
+        if (request.minPower !== undefined) {
+            const target = newRequest.targetPower !== undefined ? newRequest.targetPower : this.prevRequest.targetPower;
+            if (target && target < request.minPower) {
+                newRequest.targetPower = request.minPower;
+            }
+            else {
+                if (this.prevRequest)
+                    newRequest.targetPower = this.prevRequest.targetPower;
+            }
+            newRequest.minPower = request.minPower;
+        }
+    }
+    checkMaxPower(request, newRequest) {
+        if (request.maxPower !== undefined) {
+            const target = newRequest.targetPower !== undefined ? newRequest.targetPower : this.prevRequest.targetPower;
+            if (target && target > request.maxPower) {
+                newRequest.targetPower = request.maxPower;
+            }
+            else {
+                if (this.prevRequest)
+                    newRequest.targetPower = this.prevRequest.targetPower;
+            }
+            newRequest.maxPower = request.maxPower;
+        }
+    }
     calculateSpeedAndDistance(power, slope, m, t, props = {}) {
-        const prevData = this.data || {};
+        const prevData = this.getData();
         const vPrev = (prevData.speed || 0) / 3.6;
         const EkinPrev = 1 / 2 * m * vPrev * vPrev;
         let powerToMaintainSpeed = calculations_1.default.calculatePower(m, vPrev, slope, props);
@@ -57,8 +140,57 @@ class PowerBasedCyclingModeBase extends cycling_mode_1.CyclingModeBase {
             return { speed, distance };
         }
     }
+    updateSpeedAndDistance(power, slope, bikeType, data, prevData) {
+        const distanceInternal = prevData.distanceInternal || 0;
+        const m = this.getWeight();
+        const t = this.getTimeSinceLastUpdate();
+        const { speed, distance } = this.calculateSpeedAndDistance(power, slope, m, t, { bikeType });
+        if (power === 0 && speed < MIN_SPEED) {
+            data.speed = prevData.speed < 1 ? 0 : prevData.speed - 1;
+            data.distanceInternal = distanceInternal || 0 + data.speed / 3.6 * t;
+        }
+        else {
+            data.speed = speed;
+            data.distanceInternal = distanceInternal + distance;
+        }
+        return t;
+    }
+    getCalcBasics(bikeData) {
+        var _a;
+        const prevData = JSON.parse(JSON.stringify(this.getData()));
+        const data = Object.assign({}, this.getData());
+        const prevRequest = this.prevRequest || {};
+        const bikeType = (_a = this.getSetting('bikeType')) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+        const slope = (prevData.slope !== undefined ? prevData.slope : prevRequest.slope || 0);
+        this.copyBikeData(data, bikeData);
+        return { data, prevData, prevRequest, bikeType, slope };
+    }
+    copyBikeData(data, bikeData) {
+        var _a;
+        const keys = Object.keys(bikeData);
+        keys.forEach(key => {
+            if (bikeData[key] === null)
+                delete data[key];
+            if (key === 'slope')
+                return;
+            else if (bikeData[key] !== undefined)
+                data[key] = bikeData[key];
+        });
+        if (data.distanceInternal === undefined)
+            data.distanceInternal = 0;
+        if (data.time === undefined)
+            data.time = 0;
+        if (data.slope === undefined)
+            data.slope = 0;
+        if (bikeData.isPedalling === undefined)
+            data.isPedalling = data.pedalRpm > 0;
+        if (((_a = this.prevRequest) === null || _a === void 0 ? void 0 : _a.slope) !== undefined) {
+            data.slope = this.prevRequest.slope;
+        }
+        return data;
+    }
     calculatePowerAndDistance(speed, slope, m, t, props = {}) {
-        const prevData = this.data || {};
+        const prevData = this.getData();
         const vPrev = (prevData.speed || 0) / 3.6;
         const EkinPrev = 1 / 2 * m * vPrev * vPrev;
         const vTarget = (speed || 0) / 3.6;
@@ -71,5 +203,50 @@ class PowerBasedCyclingModeBase extends cycling_mode_1.CyclingModeBase {
         this.data.power = power;
         return { power, distance };
     }
+    getBikeInitRequest() {
+        return {};
+    }
+    sendBikeUpdate(incoming) {
+        if (this.logger)
+            this.logger.logEvent({ message: "processing update request", request: incoming, prev: this.prevRequest, data: this.getData() });
+        let newRequest = {};
+        const request = Object.assign({}, incoming);
+        try {
+            const req = this.checkForResetOrEmpty(request);
+            if (req)
+                return req;
+            this.checkSlope(request);
+            this.checkForTempPowerAdjustments(request);
+            this.checkTargetPowerSet(request, newRequest);
+            this.checkRefresh(request, newRequest);
+            this.checkMaxPower(request, newRequest);
+            this.checkMinPower(request, newRequest);
+            this.checkEmptyRequest(newRequest);
+            this.prevRequest = JSON.parse(JSON.stringify(newRequest));
+        }
+        catch (err) {
+            if (this.logger)
+                this.logger.logEvent({ message: "error", fn: 'sendBikeUpdate()', error: err.message, stack: err.stack });
+        }
+        return newRequest;
+    }
+    updateData(bikeData, log = true) {
+        try {
+            const { data, prevData, slope, bikeType } = this.getCalcBasics(bikeData);
+            const t = this.updateSpeedAndDistance(data.power, slope, bikeType, data, prevData);
+            data.time = (data.speed > 0) ? data.time + t : data.time;
+            if (log && this.logger)
+                this.logger.logEvent({ message: "updateData result", mode: this.getName(), data, bikeData });
+            this.data = data;
+            this.prevUpdateTS = Date.now();
+            return data;
+        }
+        catch (err) {
+            if (this.logger)
+                this.logger.logEvent({ message: 'error', fn: 'updateData()', error: err.message || err });
+            return this.getData();
+        }
+    }
 }
+PowerBasedCyclingModeBase.config = { name: '', description: '', properties: [] };
 exports.default = PowerBasedCyclingModeBase;

package/lib/modes/power-meter.d.ts

@@ -1,20 +1,14 @@
-import CyclingMode, { CyclingModeProperty, IncyclistBikeData, Settings, UpdateRequest } from '../modes/cycling-mode';
+import ICyclingMode, { IncyclistBikeData, Settings, UpdateRequest } from './types';
 import PowerBasedCyclingModeBase from './power-base';
-import { ControllableDeviceAdapter } from '..';
-export declare const config: {
-    name: string;
-    description: string;
-    properties: any[];
-};
-export default class PowerMeterCyclingMode extends PowerBasedCyclingModeBase implements CyclingMode {
-    constructor(adapter: ControllableDeviceAdapter, props?: Settings);
-    getName(): string;
-    getDescription(): string;
-    getProperties(): CyclingModeProperty[];
-    getProperty(name: string): CyclingModeProperty;
+import { IncyclistDeviceAdapter } from '..';
+export default class PowerMeterCyclingMode extends PowerBasedCyclingModeBase implements ICyclingMode {
+    protected static config: {
+        name: string;
+        description: string;
+        properties: any[];
+    };
+    constructor(adapter: IncyclistDeviceAdapter, props?: Settings);
     getBikeInitRequest(): UpdateRequest;
     sendBikeUpdate(request?: UpdateRequest): UpdateRequest;
-    updateData(bikeData: IncyclistBikeData, props?: {
-        log: boolean;
-    }): IncyclistBikeData;
+    copyBikeData(data: IncyclistBikeData, bikeData: IncyclistBikeData): IncyclistBikeData;
 }

package/lib/modes/power-meter.js

@@ -3,76 +3,37 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.config = void 0;
 const power_base_1 = __importDefault(require("./power-base"));
-const MIN_SPEED = 10;
-exports.config = {
-    name: 'PowerMeter',
-    description: 'Power and cadence are taken from device. Speed is calculated from power and current slope\nThis mode will not respect maximum power and/or workout limits',
-    properties: []
-};
 class PowerMeterCyclingMode extends power_base_1.default {
     constructor(adapter, props) {
         super(adapter, props);
         this.initLogger('PowerMeterMode');
-        this.data = { speed: 0, slope: 0, power: 0, distanceInternal: 0, pedalRpm: 0, isPedalling: false, heartrate: 0 };
-    }
-    getName() {
-        return exports.config.name;
-    }
-    getDescription() {
-        return exports.config.description;
-    }
-    getProperties() {
-        return exports.config.properties;
-    }
-    getProperty(name) {
-        return exports.config.properties.find(p => p.name === name);
+        this.data.slope = 0;
     }
     getBikeInitRequest() {
         return {};
     }
     sendBikeUpdate(request = {}) {
-        const prevData = this.data || {};
-        const prevSlope = prevData.slope || 0;
+        this.logger.logEvent({ message: "processing update request", request });
+        const prevData = this.data;
+        const prevSlope = prevData.slope;
         if (request.slope && request.slope !== prevSlope) {
             this.data.slope = request.slope;
-            this.updateData(this.data, { log: false });
+            this.updateData(this.data, false);
         }
-        this.logger.logEvent({ message: "processing update request", request });
         return {};
     }
-    updateData(bikeData, props = { log: true }) {
-        try {
-            const prevData = this.data || {};
-            const data = JSON.parse(JSON.stringify(bikeData));
-            let power = bikeData.power || 0;
-            const slope = prevData.slope || 0;
-            const distanceInternal = prevData.distanceInternal || 0;
-            if (power > 0) {
-                data.isPedalling = true;
-            }
-            const m = this.getWeight();
-            const t = this.getTimeSinceLastUpdate();
-            const { speed, distance } = this.calculateSpeedAndDistance(power, slope, m, t);
-            data.power = Math.round(power);
-            data.slope = slope;
-            if (power === 0 && speed < MIN_SPEED) {
-                data.speed = Math.round(prevData.speed - 1) < 0 ? 0 : Math.round(prevData.speed - 1);
-                data.distanceInternal = distanceInternal + data.speed / 3.6 * t;
-            }
-            else {
-                data.speed = speed;
-                data.distanceInternal = distanceInternal + distance;
-            }
-            if (props.log)
-                this.logger.logEvent({ message: "updateData result", data, bikeData, prevSpeed: prevData.speed, stopped: speed < MIN_SPEED });
-            this.data = data;
+    copyBikeData(data, bikeData) {
+        const newData = super.copyBikeData(data, bikeData);
+        if (bikeData.power > 0) {
+            newData.isPedalling = true;
         }
-        catch (err) {
-            this.logger.logEvent({ message: 'error', fn: 'updateData()', error: err.message || err });
-        }
-        return this.data;
+        return newData;
     }
 }
+PowerMeterCyclingMode.config = {
+    name: 'PowerMeter',
+    description: 'Power and cadence are taken from device. Speed is calculated from power and current slope\nThis mode will not respect maximum power and/or workout limits',
+    properties: []
+};
 exports.default = PowerMeterCyclingMode;

package/lib/modes/simulator.d.ts

@@ -1,5 +1,5 @@
 import { EventLogger } from "gd-eventlog";
-import { CyclingModeProperty, IncyclistBikeData, UpdateRequest } from "../modes/cycling-mode";
+import { CyclingModeProperyType, IncyclistBikeData, UpdateRequest } from "./types";
 import { Simulator } from "../simulator/Simulator";
 import PowerBasedCyclingModeBase from "./power-base";
 export type ERGEvent = {
@@ -9,21 +9,48 @@ export type ERGEvent = {
     tsStart?: number;
 };
 export default class SimulatorCyclingMode extends PowerBasedCyclingModeBase {
-    static isERG: boolean;
+    protected static config: {
+        isERG: boolean;
+        name: string;
+        description: string;
+        properties: ({
+            key: string;
+            name: string;
+            description: string;
+            type: CyclingModeProperyType;
+            options: string[];
+            default: string;
+            min?: undefined;
+            max?: undefined;
+            condition?: undefined;
+        } | {
+            key: string;
+            name: string;
+            description: string;
+            type: CyclingModeProperyType;
+            default: number;
+            min: number;
+            max: number;
+            options?: undefined;
+            condition?: undefined;
+        } | {
+            key: string;
+            name: string;
+            description: string;
+            condition: (s: any) => boolean;
+            type: CyclingModeProperyType;
+            default: number;
+            min: number;
+            max: number;
+            options?: undefined;
+        })[];
+    };
     logger: EventLogger;
     data: IncyclistBikeData;
     prevRequest: UpdateRequest;
     prevUpdateTS: number;
-    hasBikeUpdate: boolean;
-    chain: number[];
-    cassette: number[];
     event: ERGEvent;
     constructor(adapter: Simulator, props?: any);
-    getName(): string;
-    getDescription(): string;
-    getProperties(): CyclingModeProperty[];
-    getProperty(name: string): CyclingModeProperty;
     getBikeInitRequest(): UpdateRequest;
-    sendBikeUpdate(request: UpdateRequest): UpdateRequest;
     updateData(bikeData: IncyclistBikeData): IncyclistBikeData;
 }

package/lib/modes/simulator.js

@@ -3,62 +3,19 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const gd_eventlog_1 = require("gd-eventlog");
-const cycling_mode_1 = require("../modes/cycling-mode");
+const types_1 = require("./types");
 const power_base_1 = __importDefault(require("./power-base"));
 const MIN_SPEED = 10;
-const config = {
-    name: "Simulator",
-    description: "Simulates a ride with constant speed or power output",
-    properties: [
-        { key: 'mode', name: 'Simulation Type', description: '', type: cycling_mode_1.CyclingModeProperyType.SingleSelect, options: ['Speed', 'Power'], default: 'Power' },
-        { key: 'delay', name: 'Start Delay', description: 'Delay (in s) at start of training', type: cycling_mode_1.CyclingModeProperyType.Integer, default: 2, min: 0, max: 30 },
-        { key: 'power', name: 'Power', description: 'Power (in W) at start of training', condition: (s) => !s.mode || s.mode === 'Power', type: cycling_mode_1.CyclingModeProperyType.Integer, default: 150, min: 25, max: 800 },
-        { key: 'speed', name: 'Speed', description: 'Speed (in km/h) at start of training', condition: (s) => s.mode === 'Speed', type: cycling_mode_1.CyclingModeProperyType.Integer, default: 30, min: 5, max: 50 },
-        { key: 'bikeType', name: 'Bike Type', description: '', type: cycling_mode_1.CyclingModeProperyType.SingleSelect, options: ['Race', 'Mountain', 'Triathlon'], default: 'Race' }
-    ]
-};
 class SimulatorCyclingMode extends power_base_1.default {
     constructor(adapter, props) {
         super(adapter, props);
         this.prevUpdateTS = 0;
-        this.hasBikeUpdate = false;
         this.event = {};
-        this.logger = adapter.logger || new gd_eventlog_1.EventLogger('SIMMode');
-        this.data = {};
-        this.logger.logEvent({ message: 'constructor', props });
-    }
-    getName() {
-        return config.name;
-    }
-    getDescription() {
-        return config.description;
-    }
-    getProperties() {
-        return config.properties;
-    }
-    getProperty(name) {
-        return config.properties.find(p => p.name === name);
+        this.initLogger('SIMMode');
     }
     getBikeInitRequest() {
         return {};
     }
-    sendBikeUpdate(request) {
-        this.logger.logEvent({ message: 'bike update request', request });
-        const r = request || { refresh: true };
-        if (r.refresh) {
-            if (Object.keys(r).length === 1)
-                return this.prevRequest || {};
-            delete r.refresh;
-        }
-        if (request.slope !== undefined) {
-            if (!this.data)
-                this.data = {};
-            this.data.slope = request.slope;
-        }
-        this.prevRequest = request ? JSON.parse(JSON.stringify(request)) : {};
-        return r;
-    }
     updateData(bikeData) {
         const prevData = JSON.parse(JSON.stringify(this.data || {}));
         const prevSpeed = prevData.speed;
@@ -136,5 +93,16 @@ class SimulatorCyclingMode extends power_base_1.default {
         return data;
     }
 }
-SimulatorCyclingMode.isERG = true;
+SimulatorCyclingMode.config = {
+    isERG: true,
+    name: "Simulator",
+    description: "Simulates a ride with constant speed or power output",
+    properties: [
+        { key: 'mode', name: 'Simulation Type', description: '', type: types_1.CyclingModeProperyType.SingleSelect, options: ['Speed', 'Power'], default: 'Power' },
+        { key: 'delay', name: 'Start Delay', description: 'Delay (in s) at start of training', type: types_1.CyclingModeProperyType.Integer, default: 2, min: 0, max: 30 },
+        { key: 'power', name: 'Power', description: 'Power (in W) at start of training', condition: (s) => !s.mode || s.mode === 'Power', type: types_1.CyclingModeProperyType.Integer, default: 150, min: 25, max: 800 },
+        { key: 'speed', name: 'Speed', description: 'Speed (in km/h) at start of training', condition: (s) => s.mode === 'Speed', type: types_1.CyclingModeProperyType.Integer, default: 30, min: 5, max: 50 },
+        { key: 'bikeType', name: 'Bike Type', description: '', type: types_1.CyclingModeProperyType.SingleSelect, options: ['Race', 'Mountain', 'Triathlon'], default: 'Race' }
+    ]
+};
 exports.default = SimulatorCyclingMode;

package/lib/modes/{cycling-mode.d.ts → types.d.ts}

@@ -1,4 +1,4 @@
-import { ControllableDeviceAdapter } from "..";
+import { IBike } from "../types/adapter";
 export type UpdateRequest = {
     slope?: number;
     minPower?: number;
@@ -41,14 +41,14 @@ export type IncyclistBikeData = {
 export type Settings = {
     [key: string]: any;
 };
-export default interface CyclingMode {
+export default interface ICyclingMode {
     getName(): string;
     getDescription(): string;
+    getProperties(): CyclingModeProperty[];
+    getProperty(name: string): CyclingModeProperty;
     getBikeInitRequest(): UpdateRequest;
     sendBikeUpdate(request: UpdateRequest): UpdateRequest;
     updateData(data: IncyclistBikeData): IncyclistBikeData;
-    getProperties(): CyclingModeProperty[];
-    getProperty(name: string): CyclingModeProperty;
     setSettings(settings: any): any;
     setSetting(name: string, value: any): void;
     getSetting(name: string): any;
@@ -56,23 +56,26 @@ export default interface CyclingMode {
     setModeProperty(name: string, value: any): void;
     getModeProperty(name: string): any;
 }
-export declare class CyclingModeBase implements CyclingMode {
-    adapter: ControllableDeviceAdapter;
-    settings: Settings;
-    properties: Settings;
-    constructor(adapter: ControllableDeviceAdapter, props?: any);
-    setAdapter(adapter: ControllableDeviceAdapter): void;
-    getBikeInitRequest(): UpdateRequest;
+export type CyclingModeConfig = {
+    isERG?: boolean;
+    name: string;
+    description: string;
+    properties: CyclingModeProperty[];
+};
+export declare class CyclingMode implements ICyclingMode {
+    constructor(_adapter: IBike, _props?: any);
+    static supportsERGMode(): boolean;
     getName(): string;
     getDescription(): string;
-    sendBikeUpdate(request: UpdateRequest): UpdateRequest;
-    updateData(data: IncyclistBikeData): IncyclistBikeData;
     getProperties(): CyclingModeProperty[];
-    getProperty(name: string): CyclingModeProperty;
-    setSettings(settings?: any): void;
-    setSetting(name: string, value: any): void;
-    getSetting(name: string): any;
+    getProperty(_name: string): CyclingModeProperty;
+    getBikeInitRequest(): UpdateRequest;
+    sendBikeUpdate(_request: UpdateRequest): UpdateRequest;
+    updateData(_data: IncyclistBikeData): IncyclistBikeData;
+    setSettings(_settings: any): void;
+    setSetting(_name: string, _value: any): void;
+    getSetting(_name: string): void;
     getSettings(): Settings;
-    setModeProperty(name: string, value: any): void;
-    getModeProperty(name: string): any;
+    setModeProperty(_name: string, _value: any): void;
+    getModeProperty(_name: string): void;
 }

package/lib/modes/types.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CyclingMode = exports.CyclingModeProperyType = void 0;
+var CyclingModeProperyType;
+(function (CyclingModeProperyType) {
+    CyclingModeProperyType["Integer"] = "Integer";
+    CyclingModeProperyType["Boolean"] = "Boolean";
+    CyclingModeProperyType["Float"] = "Float";
+    CyclingModeProperyType["String"] = "String";
+    CyclingModeProperyType["SingleSelect"] = "SingleSelect";
+    CyclingModeProperyType["MultiSelect"] = "MultiSelect";
+})(CyclingModeProperyType || (exports.CyclingModeProperyType = CyclingModeProperyType = {}));
+class CyclingMode {
+    constructor(_adapter, _props) { }
+    static supportsERGMode() { return false; }
+    getName() {
+        throw new Error("Method not implemented.");
+    }
+    getDescription() {
+        throw new Error("Method not implemented.");
+    }
+    getProperties() {
+        throw new Error("Method not implemented.");
+    }
+    getProperty(_name) {
+        throw new Error("Method not implemented.");
+    }
+    getBikeInitRequest() {
+        throw new Error("Method not implemented.");
+    }
+    sendBikeUpdate(_request) {
+        throw new Error("Method not implemented.");
+    }
+    updateData(_data) {
+        throw new Error("Method not implemented.");
+    }
+    setSettings(_settings) {
+        throw new Error("Method not implemented.");
+    }
+    setSetting(_name, _value) {
+        throw new Error("Method not implemented.");
+    }
+    getSetting(_name) {
+        throw new Error("Method not implemented.");
+    }
+    getSettings() {
+        throw new Error("Method not implemented.");
+    }
+    setModeProperty(_name, _value) {
+        throw new Error("Method not implemented.");
+    }
+    getModeProperty(_name) {
+        throw new Error("Method not implemented.");
+    }
+}
+exports.CyclingMode = CyclingMode;