incyclist-devices 2.0.37 → 2.1.0

package/lib/simulator/Simulator.d.ts

@@ -1,29 +1,32 @@
-import DeviceAdapter, { ControllableDevice } from '../base/adpater';
-import { EventLogger } from 'gd-eventlog';
-import CyclingMode, { IncyclistBikeData } from '../modes/cycling-mode';
+/// <reference types="node" />
+import { ControllableDevice } from '../base/adpater';
+import ICyclingMode, { CyclingMode, IncyclistBikeData } from '../modes/types';
 import { DeviceProperties, DeviceSettings } from '../types/device';
+import IncyclistDevice from '../base/adpater';
+import { IncyclistDeviceAdapter } from '../types/adapter';
 interface SimulatorProperties extends DeviceProperties {
     isBot?: boolean;
     settings?: any;
     activity?: any;
 }
-export declare class Simulator extends ControllableDevice {
+export declare class SimulatorControl extends ControllableDevice<SimulatorProperties> {
+    getSupportedCyclingModes(): Array<typeof CyclingMode>;
+    getDefaultCyclingMode(): ICyclingMode;
+    sendInitCommands(): Promise<boolean>;
+}
+export declare class Simulator extends IncyclistDevice<SimulatorControl, SimulatorProperties> {
     static NAME: string;
-    logger: EventLogger;
     speed: number;
     power: number;
     cadence: number;
     time: number;
-    iv: any;
-    started: boolean;
     slope: number;
     limit: any;
     startProps?: any;
-    cyclingMode: CyclingMode;
     startTS: number;
     data: IncyclistBikeData;
     isBot: boolean;
-    ignoreHrm: boolean;
+    iv: NodeJS.Timeout;
     userSettings: {
         weight?: number;
     };
@@ -32,16 +35,10 @@ export declare class Simulator extends ControllableDevice {
     };
     constructor(settings: DeviceSettings, props?: SimulatorProperties);
     isEqual(settings: DeviceSettings): boolean;
-    isSame(device: DeviceAdapter): boolean;
+    isSame(device: IncyclistDeviceAdapter): boolean;
     getID(): string;
     getName(): string;
     getUniqueName(): string;
-    setIgnoreHrm(ignore: any): void;
-    getSupportedCyclingModes(): Array<any>;
-    getDefaultCyclingMode(): CyclingMode;
-    getCyclingMode(): CyclingMode;
-    setCyclingMode(mode: CyclingMode | string, settings?: any): void;
-    sendInitCommands(): Promise<boolean>;
     start(props?: SimulatorProperties): Promise<boolean>;
     stop(): Promise<boolean>;
     pause(): Promise<boolean>;
@@ -52,6 +49,6 @@ export declare class Simulator extends ControllableDevice {
     update(): void;
     canSendUpdate(): boolean;
     calculateDistance(speedKps: any, timeS: any): number;
-    sendUpdate(request: any): import("../modes/cycling-mode").UpdateRequest;
+    sendUpdate(request: any): import("../modes/types").UpdateRequest;
 }
 export {};

package/lib/simulator/Simulator.js

@@ -12,30 +12,41 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Simulator = void 0;
+exports.Simulator = exports.SimulatorControl = void 0;
 const adpater_1 = require("../base/adpater");
 const gd_eventlog_1 = require("gd-eventlog");
 const simulator_1 = __importDefault(require("../modes/simulator"));
 const capabilities_1 = require("../types/capabilities");
+const adpater_2 = __importDefault(require("../base/adpater"));
 const DEFAULT_PROPS = { isBot: false };
-class Simulator extends adpater_1.ControllableDevice {
+class SimulatorControl extends adpater_1.ControllableDevice {
+    getSupportedCyclingModes() {
+        return [simulator_1.default];
+    }
+    getDefaultCyclingMode() {
+        return new simulator_1.default(this.adapter);
+    }
+    sendInitCommands() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return true;
+        });
+    }
+}
+exports.SimulatorControl = SimulatorControl;
+class Simulator extends adpater_2.default {
     constructor(settings, props = DEFAULT_PROPS) {
         super(settings, props);
         this.logger = new gd_eventlog_1.EventLogger(Simulator.NAME);
+        this.setControl(new SimulatorControl(this, props));
         this.speed = 0;
         this.power = 0;
         this.cadence = 90;
-        this.paused = undefined;
         this.time = undefined;
-        this.iv = undefined;
-        this.started = false;
-        this.paused = false;
         this.slope = 0;
         this.limit = {};
         this.startTS = undefined;
         this.data = { isPedalling: false, power: 0, pedalRpm: 0, speed: 0, heartrate: 0, distanceInternal: 0 };
         this.isBot = props.isBot || false;
-        this.ignoreHrm = false;
         const name = this.getCyclingMode().getName();
         const modeSettings = this.isBot ? props.settings : this.getCyclingMode().getSettings();
         this.setCyclingMode(name, modeSettings);
@@ -55,44 +66,6 @@ class Simulator extends adpater_1.ControllableDevice {
     getID() { return Simulator.NAME; }
     getName() { return Simulator.NAME; }
     getUniqueName() { return Simulator.NAME; }
-    setIgnoreHrm(ignore) {
-        this.ignoreHrm = ignore;
-    }
-    getSupportedCyclingModes() {
-        const supported = [];
-        supported.push(simulator_1.default);
-        return supported;
-    }
-    getDefaultCyclingMode() {
-        return new simulator_1.default(this);
-    }
-    getCyclingMode() {
-        if (!this.cyclingMode)
-            this.setCyclingMode(this.getDefaultCyclingMode());
-        return this.cyclingMode;
-    }
-    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;
-        });
-    }
     start(props) {
         return __awaiter(this, void 0, void 0, function* () {
             this.startProps = props;
@@ -212,8 +185,6 @@ class Simulator extends adpater_1.ControllableDevice {
         if (this.isBot) {
             this.logger.logEvent(Object.assign({ message: 'Coach update', prevDist, prevTime }, data));
         }
-        if (this.ignoreHrm)
-            delete data.heartrate;
         this.emitData(data);
     }
     canSendUpdate() {

package/lib/types/adapter.d.ts

@@ -1,13 +1,25 @@
 /// <reference types="node" />
 import EventEmitter from "events";
-import CyclingMode from "../modes/cycling-mode";
+import ICyclingMode, { CyclingMode } from "../modes/types";
 import { IncyclistCapability } from "./capabilities";
 import { DeviceData } from "./data";
 import { DeviceProperties, DeviceSettings } from "./device";
 import { User } from "./user";
 import { EventLogger } from "gd-eventlog";
 export type OnDeviceDataCallback = (data: DeviceData) => void;
-export interface IncyclistDeviceAdapter extends EventEmitter {
+export interface IBike {
+    isControllable(): boolean;
+    setCyclingMode(mode: ICyclingMode | string, settings?: any, sendInitCommands?: boolean): void;
+    getSupportedCyclingModes(): Array<typeof CyclingMode>;
+    getCyclingMode(): ICyclingMode;
+    getDefaultCyclingMode(): ICyclingMode;
+    setBikeProps(props: DeviceProperties): void;
+    sendInitCommands(): Promise<boolean>;
+    setUser(user: User): void;
+    getWeight(): number;
+    getUser(): User;
+}
+export interface IncyclistDeviceAdapter extends EventEmitter, IBike {
     getLogger(): EventLogger;
     connect(): Promise<boolean>;
     close(): Promise<boolean>;
@@ -29,13 +41,22 @@ export interface IncyclistDeviceAdapter extends EventEmitter {
     sendUpdate(request: any): any;
     getMaxUpdateFrequency(): any;
     setMaxUpdateFrequency(value: number): any;
+    getInterface(): string;
     onData(callback: OnDeviceDataCallback): any;
 }
-export interface Bike {
-    setCyclingMode(mode: CyclingMode | string, settings?: any, sendInitCommands?: boolean): void;
-    getSupportedCyclingModes(): Array<any>;
-    getCyclingMode(): CyclingMode;
-    getDefaultCyclingMode(): CyclingMode;
-    setBikeProps(props: DeviceProperties): void;
+export declare class Controllable<P extends DeviceProperties> implements IBike {
+    protected adapter: IncyclistDeviceAdapter;
+    protected props: P;
+    protected user: User;
+    constructor(adapter: IncyclistDeviceAdapter, props?: P);
+    isControllable(): boolean;
+    setCyclingMode(mode: string | ICyclingMode, settings?: any, sendInitCommands?: boolean): void;
+    getSupportedCyclingModes(): Array<typeof CyclingMode>;
+    getCyclingMode(): ICyclingMode;
+    getDefaultCyclingMode(): ICyclingMode;
+    sendInitCommands(): Promise<boolean>;
     setUser(user: User): void;
+    getUser(): User;
+    setBikeProps(props: P): void;
+    getWeight(): number;
 }

package/lib/types/adapter.js

@@ -1,2 +1,70 @@
 "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.Controllable = void 0;
+const adpater_1 = require("../base/adpater");
+class Controllable {
+    constructor(adapter, props) {
+        this.adapter = adapter;
+        this.props = props || {};
+        this.user = {};
+    }
+    isControllable() {
+        throw new Error("Method not implemented.");
+    }
+    setCyclingMode(mode, settings, sendInitCommands) {
+        throw new Error("Method not implemented.");
+    }
+    getSupportedCyclingModes() {
+        throw new Error("Method not implemented.");
+    }
+    getCyclingMode() {
+        throw new Error("Method not implemented.");
+    }
+    getDefaultCyclingMode() {
+        throw new Error("Method not implemented.");
+    }
+    sendInitCommands() {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new Error("Method not implemented.");
+        });
+    }
+    setUser(user) {
+        this.user = user;
+        if (!user.weight)
+            this.user.weight = adpater_1.DEFAULT_USER_WEIGHT;
+    }
+    getUser() {
+        return this.user;
+    }
+    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;
+    }
+}
+exports.Controllable = Controllable;

package/lib/utils/utils.d.ts

@@ -1,6 +1,6 @@
 export declare const sleep: (ms: any) => Promise<unknown>;
 export declare const resolveNextTick: () => Promise<void>;
-export declare function runWithRetries(fn: any, maxRetries: any, timeBetween: any): Promise<unknown>;
+export declare function runWithRetries(fn: any, maxRetries: any, timeBetween: any): Promise<any>;
 export declare function floatVal(d?: number | string): number;
 export declare function intVal(d?: number | string): number;
 export declare function hexstr(arr: any, start?: any, len?: any): string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "incyclist-devices",
-  "version": "2.0.37",
+  "version": "2.1.0",
   "dependencies": {
     "@serialport/bindings-interface": "^1.2.2",
     "@serialport/parser-byte-length": "^9.0.1",
@@ -27,8 +27,8 @@
   "scripts": {
     "lint": "eslint . --ext .ts",
     "build": "tsc",
-    "test": "jest --coverage",
-    "test:ci": "jest --coverage --forceExit",
+    "test": "npx jest --coverage",
+    "test:ci": "npx jest --coverage --forceExit",
     "dev": "tsc --watch",
     "postversion": "git push && git push --tags"
   },

package/lib/antv2/modes/ant-fe-adv-st-mode.d.ts

@@ -1,9 +0,0 @@
-import { ControllableDeviceAdapter } from "../..";
-import FtmsCyclingMode from "../../modes/ble-st-mode";
-import { UpdateRequest } from "../../modes/cycling-mode";
-export default class AntAdvSimCyclingMode extends FtmsCyclingMode {
-    constructor(adapter: ControllableDeviceAdapter, props?: any);
-    getName(): string;
-    getDescription(): string;
-    sendBikeUpdate(request: UpdateRequest): UpdateRequest;
-}

package/lib/antv2/modes/ant-fe-adv-st-mode.js

@@ -1,51 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const ble_st_mode_1 = __importDefault(require("../../modes/ble-st-mode"));
-const MAX_DEVIATION = 10;
-class AntAdvSimCyclingMode extends ble_st_mode_1.default {
-    constructor(adapter, props) {
-        super(adapter, props);
-        this.initLogger('AntAdvSimMode');
-    }
-    getName() {
-        return 'Advanced Smart Trainer';
-    }
-    getDescription() {
-        return 'Sends Slope to device. Respects Limits (from workout or settings). Calculates speed based on power and slope. ';
-    }
-    sendBikeUpdate(request) {
-        const getData = () => {
-            if (!this.data)
-                return {};
-            const { gear, pedalRpm, slope, power, speed } = this.data;
-            return { gear, pedalRpm, slope, power, speed };
-        };
-        this.logger.logEvent({ message: "processing update request", request, prev: this.prevRequest, data: getData() });
-        let newRequest = {};
-        if (request.slope === undefined && request.targetPower === undefined && request.refresh && this.prevRequest) {
-            return this.prevRequest;
-        }
-        if (request.slope !== undefined) {
-            newRequest.slope = parseFloat(request.slope.toFixed(1));
-            this.data.slope = newRequest.slope;
-        }
-        if (this.data && this.data.power) {
-            const { minPower, maxPower } = request;
-            let { targetPower } = request;
-            if (minPower !== undefined && maxPower !== undefined && minPower === maxPower)
-                targetPower = maxPower;
-            if (targetPower !== undefined && Math.abs(this.data.power - targetPower) > MAX_DEVIATION)
-                newRequest.targetPower = targetPower;
-            else if (minPower !== undefined && this.data.power < minPower)
-                newRequest.targetPower = minPower;
-            else if (request.maxPower !== undefined && this.data.power > request.maxPower)
-                newRequest.targetPower = maxPower;
-        }
-        this.prevRequest = JSON.parse(JSON.stringify(newRequest));
-        return newRequest;
-    }
-}
-exports.default = AntAdvSimCyclingMode;

package/lib/antv2/modes/ant-fe-erg-mode.d.ts

@@ -1,6 +0,0 @@
-import { ControllableDeviceAdapter } from "../..";
-import BleERGCyclingMode from "../../modes/ble-erg-mode";
-export default class AntFeERGCyclingMode extends BleERGCyclingMode {
-    static isERG: boolean;
-    constructor(adapter: ControllableDeviceAdapter, props?: any);
-}

package/lib/antv2/modes/ant-fe-erg-mode.js

@@ -1,14 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const ble_erg_mode_1 = __importDefault(require("../../modes/ble-erg-mode"));
-class AntFeERGCyclingMode extends ble_erg_mode_1.default {
-    constructor(adapter, props) {
-        super(adapter, props);
-        this.initLogger('AntERGMode');
-    }
-}
-AntFeERGCyclingMode.isERG = true;
-exports.default = AntFeERGCyclingMode;

package/lib/antv2/modes/ant-fe-st-mode.d.ts

@@ -1,5 +0,0 @@
-import { ControllableDeviceAdapter } from "../..";
-import FtmsCyclingMode from "../../modes/ble-st-mode";
-export default class AntStCyclingMode extends FtmsCyclingMode {
-    constructor(adapter: ControllableDeviceAdapter, props?: any);
-}

package/lib/antv2/modes/ant-fe-st-mode.js

@@ -1,13 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const ble_st_mode_1 = __importDefault(require("../../modes/ble-st-mode"));
-class AntStCyclingMode extends ble_st_mode_1.default {
-    constructor(adapter, props) {
-        super(adapter, props);
-        this.initLogger('AntSimMode');
-    }
-}
-exports.default = AntStCyclingMode;

package/lib/modes/ble-erg-mode.d.ts

@@ -1,18 +0,0 @@
-import { ControllableDeviceAdapter } from "..";
-import CyclingMode, { CyclingModeProperty, IncyclistBikeData, UpdateRequest } from "./cycling-mode";
-import PowerBasedCyclingModeBase from "./power-base";
-export default class BleERGCyclingMode extends PowerBasedCyclingModeBase implements CyclingMode {
-    static isERG: boolean;
-    prevRequest: UpdateRequest;
-    hasBikeUpdate: boolean;
-    chain: number[];
-    cassette: number[];
-    constructor(adapter: ControllableDeviceAdapter, props?: any);
-    getName(): string;
-    getDescription(): string;
-    getProperties(): CyclingModeProperty[];
-    getProperty(name: string): CyclingModeProperty;
-    getBikeInitRequest(): UpdateRequest;
-    sendBikeUpdate(request: UpdateRequest): UpdateRequest;
-    updateData(bikeData: IncyclistBikeData): any;
-}

package/lib/modes/ble-erg-mode.js

@@ -1,148 +0,0 @@
-"use strict";
-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 power_base_1 = __importDefault(require("./power-base"));
-const config = {
-    name: "ERG",
-    description: "Calculates speed based on power and slope. Power targets are set by workout or remain stable throughout the workout",
-    properties: [
-        { key: 'bikeType', name: 'Bike Type', description: '', type: cycling_mode_1.CyclingModeProperyType.SingleSelect, options: ['Race', 'Mountain', 'Triathlon'], default: 'Race' },
-        { key: 'startPower', name: 'Starting Power', description: 'Initial power in Watts at start of training', type: cycling_mode_1.CyclingModeProperyType.Integer, default: 50, min: 25, max: 800 },
-    ]
-};
-const MIN_SPEED = 10;
-class BleERGCyclingMode extends power_base_1.default {
-    constructor(adapter, props) {
-        super(adapter, props);
-        this.hasBikeUpdate = false;
-        this.initLogger('ERGMode');
-    }
-    getName() {
-        return config.name;
-    }
-    getDescription() {
-        return config.description;
-    }
-    getProperties() {
-        return config.properties;
-    }
-    getProperty(name) {
-        return config.properties.find(p => p.name === name);
-    }
-    getBikeInitRequest() {
-        const startPower = Number(this.getSetting('startPower'));
-        this.prevRequest = { targetPower: startPower };
-        return { targetPower: startPower };
-    }
-    sendBikeUpdate(request) {
-        const getData = () => {
-            if (!this.data)
-                return {};
-            const { pedalRpm, slope, power, speed } = this.data;
-            return { pedalRpm, slope, power, speed };
-        };
-        this.logger.logEvent({ message: "processing update request", request, prev: this.prevRequest, data: getData() });
-        let newRequest = {};
-        try {
-            if (!request || request.reset) {
-                this.prevRequest = {};
-                return request.reset ? { reset: true } : {};
-            }
-            if (Object.keys(request).length === 0 && this.prevRequest) {
-                request.targetPower = this.prevRequest.targetPower;
-            }
-            const prevData = this.data || {};
-            if (request.slope !== undefined) {
-                if (!this.data)
-                    this.data = {};
-                this.data.slope = request.slope;
-            }
-            delete request.slope;
-            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;
-            }
-            if (request.targetPower !== undefined) {
-                delete request.refresh;
-                newRequest.targetPower = Number(request.targetPower);
-            }
-            if (request.refresh && request.targetPower === undefined) {
-                delete request.refresh;
-                newRequest.targetPower = this.prevRequest.targetPower;
-            }
-            if (request.targetPower === undefined && request.maxPower !== undefined && request.minPower !== undefined && request.maxPower === request.minPower) {
-                request.targetPower = request.maxPower;
-                newRequest.targetPower = request.targetPower;
-            }
-            if (request.maxPower !== undefined) {
-                if (newRequest.targetPower !== undefined && newRequest.targetPower > request.maxPower) {
-                    newRequest.targetPower = request.maxPower;
-                }
-                newRequest.maxPower = request.maxPower;
-            }
-            if (request.minPower !== undefined) {
-                if (newRequest.targetPower !== undefined && newRequest.targetPower < request.minPower) {
-                    newRequest.targetPower = request.minPower;
-                }
-                newRequest.minPower = request.minPower;
-                if (prevData.power && prevData.power < request.minPower)
-                    newRequest.targetPower = request.minPower;
-            }
-            if (Object.keys(newRequest).length === 0) {
-                if (this.prevRequest)
-                    newRequest.targetPower = this.prevRequest.targetPower;
-                newRequest.refresh = true;
-            }
-            this.prevRequest = JSON.parse(JSON.stringify(newRequest));
-        }
-        catch (err) {
-            this.logger.logEvent({ message: "error", fn: 'sendBikeUpdate()', error: err.message || err, stack: err.stack });
-        }
-        return newRequest;
-    }
-    updateData(bikeData) {
-        const prevData = JSON.parse(JSON.stringify(this.data || {}));
-        const prevSpeed = prevData.speed;
-        const prevRequest = this.prevRequest || {};
-        const data = this.data || {};
-        const bikeType = this.getSetting('bikeType').toLowerCase();
-        try {
-            let power = bikeData.power || 0;
-            const slope = (prevData.slope !== undefined ? prevData.slope : prevRequest.slope || 0);
-            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 = Math.round(prevData.speed - 1) < 0 ? 0 : Math.round(prevData.speed - 1);
-                data.distanceInternal = distanceInternal + data.speed / 3.6 * t;
-            }
-            else {
-                data.speed = (power === 0 && speed < MIN_SPEED) ? 0 : speed;
-                data.distanceInternal = (power === 0 && speed < MIN_SPEED) ? distanceInternal : distanceInternal + distance;
-            }
-            data.power = Math.round(power);
-            data.slope = slope;
-            data.pedalRpm = bikeData.pedalRpm || 0;
-            if (data.time !== undefined && data.speed > 0)
-                data.time += t;
-            else
-                data.time = 0;
-            data.heartrate = bikeData.heartrate;
-            data.isPedalling = bikeData.isPedalling;
-        }
-        catch (err) {
-            this.logger.logEvent({ message: 'error', fn: 'updateData()', error: err.message || err });
-        }
-        this.logger.logEvent({ message: "updateData result", data, bikeData, prevRequest, prevSpeed });
-        this.data = data;
-        return data;
-    }
-}
-BleERGCyclingMode.isERG = true;
-exports.default = BleERGCyclingMode;

package/lib/modes/ble-st-mode.d.ts

@@ -1,15 +0,0 @@
-import { ControllableDeviceAdapter } from "..";
-import CyclingMode, { CyclingModeProperty, IncyclistBikeData, UpdateRequest } from "../modes/cycling-mode";
-import PowerBasedCyclingModeBase from "../modes/power-base";
-export default class FtmsCyclingMode extends PowerBasedCyclingModeBase implements CyclingMode {
-    prevRequest: UpdateRequest;
-    hasBikeUpdate: boolean;
-    constructor(adapter: ControllableDeviceAdapter, props?: any);
-    getName(): string;
-    getDescription(): string;
-    getProperties(): CyclingModeProperty[];
-    getProperty(name: string): CyclingModeProperty;
-    getBikeInitRequest(): UpdateRequest;
-    sendBikeUpdate(request: UpdateRequest): UpdateRequest;
-    updateData(bikeData: IncyclistBikeData): any;
-}